Yi.Syntax.JavaScript

Data types, classes and instances

class Strokable a where

Instances of Strokable are datatypes which can be syntax highlighted.

Methods

toStrokes :: a -> Endo [Stroke]

Instances

Strokable (Tok Token)

Strokable (KeyValue TT)

Strokable (Array TT)

Strokable (Expr TT)

Strokable (VarDecAss TT)

Strokable (Block TT)

Strokable (ForContent TT)

Strokable (ParExpr TT)

Strokable (Parameters TT)

Strokable (Statement TT)

TODO: This code is *screaming* for some generic programming.

TODO: Somehow fix Failable and failStroker to be more generic. This will make these instances much nicer and we won't have to make ad-hoc stuff like this.

class Failable f where

Instances of Failable can represent failure. This is a useful class for future work, since then we can make stroking much easier.

Methods

stupid :: t -> f t

hasFailed :: f t -> Bool

Instances

Failable KeyValue

Failable Expr

Failable VarDecAss

Failable Block

Failable ForContent

Failable ParExpr

Failable Parameters

type BList a = [a]

type Tree t = BList (Statement t)

type Semicolon t = Maybe t

data Statement t

Constructors

FunDecl t t (Parameters t) (Block t)

VarDecl t (BList (VarDecAss t)) (Semicolon t)

Return t (Maybe (Expr t)) (Semicolon t)

While t (ParExpr t) (Block t)

DoWhile t (Block t) t (ParExpr t) (Semicolon t)

For t t (Expr t) (ForContent t) t (Block t)

If t (ParExpr t) (Block t) (Maybe (Statement t))

Else t (Block t)

With t (ParExpr t) (Block t)

Comm t

Expr (Expr t) (Semicolon t)

Instances

Typeable1 Statement

Foldable Statement

IsTree Statement

Data t => Data (Statement t)

Show t => Show (Statement t)

Strokable (Statement TT)

TODO: This code is *screaming* for some generic programming.

TODO: Somehow fix Failable and failStroker to be more generic. This will make these instances much nicer and we won't have to make ad-hoc stuff like this.

data Parameters t

Constructors

Parameters t (BList t) t

ParErr t

Instances

Typeable1 Parameters

Foldable Parameters

Failable Parameters

Data t => Data (Parameters t)

Show t => Show (Parameters t)

Strokable (Parameters TT)

data ParExpr t

Constructors

ParExpr t (BList (Expr t)) t

ParExprErr t

Instances

Typeable1 ParExpr

Foldable ParExpr

Failable ParExpr

Data t => Data (ParExpr t)

Show t => Show (ParExpr t)

Strokable (ParExpr TT)

data ForContent t

Constructors

ForNormal t (Expr t) t (Expr t)

ForIn t (Expr t)

ForErr t

Instances

Typeable1 ForContent

Foldable ForContent

Failable ForContent

Data t => Data (ForContent t)

Show t => Show (ForContent t)

Strokable (ForContent TT)

data Block t

Constructors

Block t (BList (Statement t)) t

BlockOne (Statement t)

BlockErr t

Instances

Typeable1 Block

Foldable Block

Failable Block

Data t => Data (Block t)

Show t => Show (Block t)

Strokable (Block TT)

data VarDecAss t

Represents either a variable name or a variable name assigned to an expression. AssBeg is a variable name maybe followed by an assignment. AssRst is an equals sign and an expression. (AssBeg x (Just (AssRst '=' '5'))) means x = 5.

Constructors

AssBeg t (Maybe (VarDecAss t))

AssRst t (Expr t)

AssErr t

Instances

Typeable1 VarDecAss

Foldable VarDecAss

Failable VarDecAss

Data t => Data (VarDecAss t)

Show t => Show (VarDecAss t)

Strokable (VarDecAss TT)

data Expr t

Constructors

ExprObj t (BList (KeyValue t)) t

ExprPrefix t (Expr t)

ExprNew t (Expr t)

ExprSimple t (Maybe (Expr t))

ExprParen t (Expr t) t (Maybe (Expr t))

ExprAnonFun t (Parameters t) (Block t)

ExprTypeOf t (Expr t)

ExprFunCall t (ParExpr t) (Maybe (Expr t))

OpExpr t (Expr t)

ExprCond t (Expr t) t (Expr t)

ExprArr t (Maybe (Array t)) t (Maybe (Expr t))

PostExpr t

ExprErr t

Instances

Typeable1 Expr

Foldable Expr

Failable Expr

Data t => Data (Expr t)

Show t => Show (Expr t)

Strokable (Expr TT)

data Array t

Constructors

ArrCont (Expr t) (Maybe (Array t))

ArrRest t (Array t) (Maybe (Array t))

ArrErr t

Instances

Typeable1 Array

Foldable Array

Data t => Data (Array t)

Show t => Show (Array t)

Strokable (Array TT)

data KeyValue t

Constructors

KeyValue t t (Expr t)

KeyValueErr t

Instances

Typeable1 KeyValue

Foldable KeyValue

Failable KeyValue

Data t => Data (KeyValue t)

Show t => Show (KeyValue t)

Strokable (KeyValue TT)

Helper functions.

normal :: TT -> Endo [Stroke]

Normal stroker.

error :: TT -> Endo [Stroke]

Error stroker.

one :: (t -> a) -> t -> Endo [a]

modStroke :: StyleName -> Stroke -> Stroke

Given a new style and a stroke, return a stroke with the new style appended to the old one.

Stroking functions

nError :: [TT] -> [TT] -> Endo [Stroke]

Given a list of tokens to check for errors (xs) and a list of tokens to stroke (xs'), returns normal strokes for xs' if there were no errors. Otherwise returns error strokes for xs'.

failStroker :: [TT] -> TT -> Endo [Stroke]

Given a list of TT, if any of them is an error, returns an error stroker, otherwise a normal stroker. Using e.g. existentials, we could make this more general and have support for heterogeneous lists of elements which implement Failable, but I haven't had the time to fix this.

tokenToStroke :: TT -> Stroke

Given a TT, return a Stroke for it.

getStrokes :: Tree TT -> Point -> Point -> Point -> [Stroke]

The main stroking function.

The parser

parse :: P TT (Tree TT)

Main parser.

statement :: P TT (Statement TT)

Parser for statements such as return, while, do-while, for, etc.

block :: P TT (Block TT)

Parser for blocks, i.e. a bunch of statements wrapped in curly brackets or just a single statement.

Note that this works for JavaScript 1.8 lambda style function bodies as well, e.g. function hello() 5, since expressions are also statements and we don't require a trailing semi-colon.

TODO: function hello() var x; is not a valid program.

stmtExpr :: P TT (Expr TT)

Parser for expressions which may be statements. In reality, any expression is also a valid statement, but this is a slight compromise to get rid of the massive performance loss which is introduced when allowing JavaScript objects to be valid statements.

opExpr :: P TT (Expr TT)

The basic idea here is to parse the rest of expressions, e.g. + 3 in x + 3 or [i] in x[i]. Anything which is useful in such a scenario goes here. TODO: This accepts [], but shouldn't, since x[] is invalid.

expression :: P TT (Expr TT)

Parser for expressions.

array :: P TT (Expr TT)

Parses both empty and non-empty arrays. Should probably be split up into further parts to allow for the separation of [] and [1, 2, 3].

Parsing helpers

semicolon :: P TT (Maybe TT)

Parses a semicolon if it's there.

parameters :: P TT (Parameters TT)

Parses a comma-separated list of valid identifiers.

parExpr :: P TT (ParExpr TT)

Simple parsers

comment :: P TT TT

Parses a comment.

preOp :: P TT TT

Parses a prefix operator.

inOp :: P TT TT

Parses a infix operator.

postOp :: P TT TT

Parses a postfix operator.

opTok :: P TT TT

Parses any literal.

simpleTok :: P TT TT

Parses any literal.

strTok :: P TT TT

Parses any string.

numTok :: P TT TT

Parses any valid number.

name :: P TT TT

Parses any valid identifier.

boolean :: P TT TT

Parses any boolean.

res :: Reserved -> P TT TT

Parses a reserved word.

spc :: Char -> P TT TT

Parses a special token.

oper :: Operator -> P TT TT

Parses an operator.

Recovery parsers

plzTok :: P TT TT -> P TT TT

Expects a token x, recovers with errorToken.

plzSpc :: Char -> P TT TT

Expects a special token.

plzExpr :: P TT (Expr TT)

Expects an expression.

plz :: Failable f => P TT (f TT) -> P TT (f TT)

anything :: P s TT

General recovery parser, inserts an error token.

hate :: Int -> P s a -> P s a

Weighted recovery.

Utility stuff

fromBlock :: Block t -> [Statement t]

firstTok :: Foldable f => f t -> t

errorToken :: TT

isError :: TT -> Bool

toTT :: t -> Tok t

Better name for tokFromT.

fromTT :: Tok t -> t

Better name for tokT.