miniscript.nex

/\n/ {
  log.Token("NEWLINE\n")
  log.Trace("lex", "Newline")
  return NEWLINE
}

/<script type=\"text\/JavaScript\">/ {
  log.Token("SCRIPT_TAG_START ")
  log.Trace("lex", "Start script tag")
  return SCRIPT_TAG_START
}

/<\/script>/ {
  log.Token("SCRIPT_TAG_END ")
  log.Trace("lex", "End script tag")
  return SCRIPT_TAG_END
}

/document\.write/ {
  log.Token("DOCUMENT_WRITE ")
  log.Trace("lex", "Document write function call")
  return DOCUMENT_WRITE
}

/assert/ {
  log.Token("ASSERT ")
  log.Trace("lex", "Assert ")
  return ASSERT
}

/function/ {
  log.Token("FUNCTION ")
  log.Trace("lex", "Function def ")
  return FUNCTION
}

/return/ {
  log.Token("RETURN ")
  log.Trace("lex", "Return ")
  return RETURN
}

/true/ {
  log.Token("TRUE ")
  log.Trace("lex", "True ")
  lval.N = &ast.Value{Type: ast.VALUE_BOOLEAN, Value: true, Line: log.LineNo}
  return TRUE
}

/false/ {
  log.Token("FALSE ")
  log.Trace("lex", "False ")
  lval.N = &ast.Value{Type: ast.VALUE_BOOLEAN, Value: false, Line: log.LineNo}
  return FALSE
}

/if/ {
  log.Token("IF ")
  log.Trace("lex", "If statement")
  return IF
}

/else/ {
  log.Token("ELSE ")
  log.Trace("lex", "Else statement")
  return ELSE
}

/while/ {
  log.Token("WHILE ")
  log.Trace("lex", "While statement")
  return WHILE
}

/do/ {
  log.Token("DO ")
  log.Trace("lex", "Do statement")
  return DO
}

/break/ {
  log.Token("BREAK ")
  log.Trace("lex", "Break clause")
  lval.N = &ast.Break{Line: log.LineNo}
  return BREAK
}

/continue/ {
  log.Token("CONTINUE ")
  log.Trace("lex", "Continue clause")
  lval.N = &ast.Continue{Line: log.LineNo}
  return CONTINUE
}

/var[ \t]/ {
  log.Token("VARDEF ")
  log.Trace("lex", "Var keyword")
  return VARDEF
}

/[ \t]+/ {
  log.Token("")
}

/[0-9]+/ {
  log.Token("INTEGER[" + yylex.Text() + "] ")
  log.Trace("lex", "Integer " + yylex.Text())
  integer, _ := strconv.Atoi(yylex.Text())
  lval.N = &ast.Value{Type: ast.VALUE_INT, Value: integer, Line: log.LineNo}
  return INTEGER
}

/[A-Za-z][A-Za-z0-9]*\.[A-Za-z][A-Za-z0-9]*/ {
  log.Token("OBJKEY[" + yylex.Text() + "] ")
  log.Trace("lex", "Object Key " + yylex.Text())
  lval.Str = yylex.Text()
  return OBJKEY
}

/[A-Za-z][A-Za-z0-9]*/ {
  log.Token("IDENTIFIER[" + yylex.Text() + "] ")
  log.Trace("lex", "Identifier " + yylex.Text())
  lval.Str = yylex.Text()
  return IDENTIFIER
}

/\"(\\.|[^\\"\n])*\"/ {
  log.Token("STRING[" + yylex.Text() + "] ")
  log.Trace("lex", "String " + yylex.Text())
  lval.N = &ast.Value{Type: ast.VALUE_STRING, Value: yylex.Text()[1:len(yylex.Text())-1], Line: log.LineNo}
  return STRING
}

/=/ {
  log.Token("EQUAL ")
  log.Trace("lex", "Equal sign")
  return EQUAL
}

/{/ {
  log.Token("LBRACE ")
  log.Trace("lex", "Left brace")
  return LBRACE
}

/}/ {
  log.Token("RBRACE ")
  log.Trace("lex", "Right brace")
  return RBRACE
}

/\[/ {
  log.Token("LBRACKET ")
  log.Trace("lex", "Left bracket")
  return LBRACKET
}

/\]/ {
  log.Token("RBRACKET ")
  log.Trace("lex", "Right bracket")
  return RBRACKET
}

/\(/ {
  log.Token("LPAREN ")
  log.Trace("lex", "Left paren")
  return LPAREN
}

/\)/ {
  log.Token("RPAREN ")
  log.Trace("lex", "Right paren")
  return RPAREN
}

/,/ {
  log.Token("COMMA ")
  log.Trace("lex", "Comma")
  return COMMA
}

/\+/ {
  log.Token("PLUS ")
  log.Trace("lex", "Plus")
  return PLUS
}

/-/ {
  log.Token("MINUS ")
  log.Trace("lex", "Minus")
  return MINUS
}

/\*/ {
  log.Token("MULT ")
  log.Trace("lex", "Mult")
  return MULT
}

/\// {
  log.Token("DIVIDE ")
  log.Trace("lex", "Divide")
  return DIVIDE
}

/:/ {
  log.Token("COLON ")
  log.Trace("lex", "Colon")
  return COLON
}

/;/ {
  log.Token("SEMICOLON ")
  log.Trace("lex", "Semicolon")
  return SEMICOLON
}

/</ {
  log.Token("LT ")
  log.Trace("lex", "Less Than")
  return LT
}

/>/ {
  log.Token("GT ")
  log.Trace("lex", "Greater Than")
  return GT
}

/<=/ {
  log.Token("LTE ")
  log.Trace("lex", "Less than or equal to")
  return LTE
}

/>=/ {
  log.Token("GTE ")
  log.Trace("lex", "Greater than or equal to")
  return GTE
}

/==/ {
  log.Token("EQUIV ")
  log.Trace("lex", "Equivalence")
  return EQUIV
}

/!=/ {
  log.Token("NEQUIV ")
  log.Trace("lex", "NonEquivalence")
  return NEQUIV
}

/!/ {
  log.Token("NOT ")
  log.Trace("lex", "Not")
  return NOT
}

/&&/ {
  log.Token("AND ")
  log.Trace("lex", "And")
  return AND
}

/\|\|/ {
  log.Token("OR ")
  log.Trace("lex", "Or")
  return OR
}

/./ {
  return int(yylex.Text()[0])
}

//

package main

import (
  "fmt"
  "os"
  "strconv"
  "mhoc.co/msp/ast"
  "mhoc.co/msp/log"
)