Jispotalk

Jispotalk is a Python dialect in which all operators precede their operands, and parentheses are used for all grouping (except string literals, which as in Python are delimited with single or double quotes). Jispotalk code can be embedded in a Bracetagger text file. Bracetagger is similar to HTML, except open tags begin with a brace bracket and a keyword, and the closing tag is simply a close brace bracket. Any text enclosed in a tag is preceded by a vertical slash (|). File extensions include .JPT (source code), .JPA (assembler code), .JPC (compiled code), and .BT (Bracetagger).

Keyboard Aid

This optional feature enables hyphens, open parentheses, and close parentheses to be entered by typing semicolons, commas, and periods, respectively. When enabled, keyboard aid can be temporarily suppressed by using the Ctrl key in conjunction with typing semicolons, commas, and periods (no character substitution takes place). By convention, hyphens are used to separate words in multi-word identifiers, but semicolons are easier to type than hyphens. Similarly, commas and periods are easier to type than parentheses. When entering Bracetagger code, vertical slashes, open braces, and close braces are entered by typing forward slashes, commas, and periods, respectively.

Special Characters

• ()  grouping
• -_  used in identifiers
• -;  end of stmt.
• :  dot operator
• " '  string delimiters
• \  escape char.
• #  comment
• {* *}  block comment
• { }  Bracetagger code
• \*}  treated as Bracetagger code, not block comment

Differences from Python

• Parentheses, not whitespace
• Integration with Bracetagger
• Operators come before their operands
• Single, not multiple inheritance
• Adds interfaces ("scool" defs.)
• Drops iterators and generators
• Adds lambdas
• Adds quote and list-compile functions, treating code as data

Grammar Notation

• Non-terminal symbol: <symbol name>
• Optional text in brackets: [ text ]
• Repeats zero or more times: [ text ]...
• Repeats one or more times: <symbol name>...
• Pipe separates alternatives: opt1 | opt2
• Comments in italics
• Advanced features flagged as **

Compiler and Assembler

The Jispotalk Compiler translates source code into compiled code, and optionally into assembler code. Assembler code is an intermediate language which is much simpler than source code, although both source code and assembler code are in the form of text files. During Jispotalk development, the developer uses the Jispotalk Assembler, which converts assembler code (hand-written by the developer) into compiled code. This is a necessary step enabling the JispoTalk Runtime Environment (JTRE) to be tested prior to the development of the Jispotalk Compiler.

Assembler Grammar

Each token is separated from adjacent tokens with white space. Parentheses count as tokens. Consecutive parentheses need no separating white space.

<source file>:

• <module>...

<module>:

• ( <mod>] [<global>] [<class>]... )

<global>:

• ( module ( [<impmod>]... ) [<def>]... [<glbdef>] )

<class>:

• ( <class id> ( [<mod>] <base id> )( [<var>]... ) [<def>]... )

<def>:

• ( <id> ( [<parm>]... )( [<var>]... ) <block> )

<glbdef>:

• ( global ( [<var>]... ) <block> )

<mod>:
<class id>:
<base id>:
<parm>:
<var>:

• <id> // identifier

<impmod>:

• <tupmod> [ ( <tuple>... ) ]

<tupmod>: // no spaces

• <mod>
• <mod> : <id>

<tuple>: // no spaces

• <id>
• <id> : <id>

<block>:

• ( <hdr> [<tok>]... )

<tok>:

• <keyword>
• <expr>

<expr>:

• <functok>
• <vartok>
• <const>
• <block>
• <dot expr>

<functok>: // no spaces

• [[ <mod> : ] [<class id>]] : <id>

<vartok>: // no spaces

• <id> // local var.
• [[ <mod> : ] [<class id>]] : <id>

<const>:

• <num> // integer
• <float> // no. with dec. pt.
• <string lit>

<hdr>:

• <keyword>
• <lvfunc>
• <functok>

<lvfunc>:

• <id> // built-in function

<dot expr>:

• ( dot <vartok><dotelem>... )

<dotelem>:

• <vartok>
• ( <functok> [<expr>]... )

// must occur on line by itself
// no white space before #

<comment>:

• # [<char>]...

Jispotalk Grammar

White space occurs between tokens (parentheses need no adjacent white space, also any semicolon/hyphen before a close parenthesis may be omitted):

<source file>:

• [<line-comment>] [<vars>] [ do <block>] [<dec def>]... [<class>]... [ do <block>]

<import stmt>:

• import <module>
• import ( <module>... )
• from <rel module> import <mod list>
• from <rel module> import *

<module>:

• <name>
• ( <name> as <name> )
• ( : <name>... [ as <name>] )

<mod list>:

• <id as>
• ( <id as>... )

<id as>:

• <mod id>
• ( <mod id> as <name> )

<mod id>:

• <mod name>
• <class name>
• <func name>
• <var name>

<rel module>:

• ( <colon list> [<name>]... )
• <name> // ?

<class>:

• ( <cls typ> <name> [<base class>][<does>] [<vars>] do <dec def>... )
• ( scool <name> [<does>] do [<const decl>]... [<dec hdr>]... )

<cls typ>:

• class
• abclass

<does>:

• does ( <scool name>... )

<scool name>:
<base class>:

• <name>
• ( : <name><name>... )

<const decl>:

• const <name><const expr> ;

<dec hdr>:

• [<dec>]... <def hdr>

<dec def>:

• [<dec>]... <def>

<dec>:

• @ <call expr>

<def hdr>:

• def <name> ( [<var>]... )

<def>:

• def <name> ( [<var>]... ) [<vars>] do <block>

<vars>:

• var ( <var>... )

<var>:

• <id>

<block>:

• ( [<stmt-semi>]... [<stmt>] )

<stmt-semi>:

• <stmt><endchar>
• <bt tag>

<endchar>:   // must be followed by white space

• ; | -

<jump stmt>:

• <continue stmt>
• <break stmt>
• <return stmt>

<pjump stmt>:

• return <expr>
• ** <raise stmt>

<raise stmt>:

• raise [<expr> [ from <expr>]]

<stmt>:

• <open stmt>
• <closed stmt>

<open stmt>:

• <if stmt>
• <while stmt>
• <for stmt>
• ** <try stmt>
• <pjump stmt>
• <pcall stmt>
• <asst stmt>
• <del stmt>
• <import stmt>

<closed stmt>:

• <jump stmt>
• <call stmt>
• <print stmt>
• <bt tag>

<bt tag>:

• { ... }

<call expr>:

• ( <name> [<expr>]... )
• ( : <obj expr> [<colon expr>]... ( <method name> [<expr>]... ))
• ( call <expr>... )

<call stmt>:

• ( <name> [<expr>]... )

<pcall stmt>:

• : <obj expr> [<colon expr>]... ( <method name> [<expr>]... )
• call <expr>...

<colon expr>:

• <name>
• ( <name> [<expr>]... )

<asst stmt>:

• <asst op><name><expr>
• <asst op><target expr><expr>

<asst op>:

• set | addset | minusset | mpyset | divset |
• idivset | modset | shlset | shrset |
• andset | orset | xorset

<target expr>:

• ( : <name> [<colon expr>]... <name> )
• ( slice <arr><expr> [<expr>] )
• ( slice <arr><expr> all )

<arr>:   string or array

• <name>
• <expr>

<if stmt>:

• if <expr> do <block> [ elif <expr> do <block>]... [ else <block>]

<while stmt>:

• while <expr> do <block>

<for stmt>:

• for <name> in <expr> do <block>

<try stmt>:

• try <block> <except clause>... [ else <block>] [ finally <block>]
• try <block> finally <block>

<except clause>:

• except <name> [ as <name>] <block>

<return stmt>:

• return

<break stmt>:

• break

<continue stmt>:

• continue

<del stmt>:

• del <expr>

<paren stmt>:

• ( <open stmt> )
• <closed stmt>

<qblock>:

• ( quote [<paren stmt>]... )

<expr>:

• <keyword const>
• <literal>
• <name>
• ( <unary op><expr> )
• ( <bin op><expr><expr> )
• ( <multi op><expr><expr>... )
• ( quest <expr><expr><expr> )
• <lambda>
• ( quote <expr>... )
• <array expr>
• <dict expr>
• <bitarray expr>
• <string expr>
• <bytezero expr>
• <bytes expr>
• <target expr>
• <obj expr>
• <cast>

<obj expr>:

• <name>
• <call stmt>

<unary op>:

• minus  negate
• notbits  bitwise not
• not

<bin op>:

• <arith op>
• <comparison op>
• <shift op>
• <bitwise op>
• <boolean op>

<arith op>:

• div | idiv | mod | mpy | add | minus

<comparison op>:

• ge | le | gt | lt | eq | ne | is | in

<shift op>:

• shl | shr

<bitwise op>:

• andbits | orbits | xorbits

<boolean op>:

• and | or | xor

<multi op>:

• mpy | add | or | and |
• strdo  % operator
• strcat  + operator

<const expr>:

• <literal>
• <keyword const>

<literal>:

• <num lit>
• <string lit>
• <bytes lit>

<array expr>:

• ( array [<expr>]... )

<bitarray expr>:

• ( bitarray [<expr>] )

<dict expr>:

• ( dict [ <pair>]... )

<pair>:

• ( <name><expr> )
• ( <literal><expr> )

<cast>:

• ( cast <type><expr> )

<print stmt>:  // built-in function

• ( print [<expr>]... )
• ( echo [<expr>]... )

<lambda>:  // must pass qblock thru compile func

• ( lambda ( [<id>]... ) <expr> )
• ( lambda ( [<id>]... ) do <block> )
• ( lambda ( [<id>]... ) do <qblock> )

No white space allowed between tokens, for rest of Jispotalk Grammar:

<white space>:

• <white token>...

<white token>:

• <rest-comment>
• <non-line-comment>

<rest-comment>:

• <non-line-comment><line-comment>

<line-comment>:

• # [<char>]... <new-line>

<non-line-comment>:

• <white char>
• <blk-comment>

<blk-comment>:

• {* [<char>]... *}

<white char>:

• <space> | <tab> | <new-line>

<name>:

• [<underscore>]... <letter> [<alnum>]... [<hyphen-alnum>]... [<underscore>]...

<hyphen-alnum>:

• <hyphen><alnum>...

<alnum>:

• <letter>
• <digit>

In plain English, names begin and end with zero or more underscores. In between is a letter followed by zero or more alphanumeric characters. Names may also contain hyphens, where each hyphen is preceded and succeeded by an alphanumeric character.

<num lit>:

• <dec int>
• <oct int>
• <hex int>
• <bin int>
• <float>

<dec int>:

• 0
• [<hyphen>] <any digit except 0> [<digit>]...

<float>:

• <dec int> <fraction> [<exponent>]
• <dec int> <exponent>

<fraction>:

• <dot> [<digit>]...

<exponent>:

• <e> [<sign>] <digit>...

<e>:

• e | E

<sign>:

• + | -

<oct int>:

• 0o <octal digit>...

<hex int>:

• 0x <hex digit>...
• 0X <hex digit>...

<bin int>:

• 0b <zero or one>...
• 0B <zero or one>...

<octal digit>:

• 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7

<hex digit>:

• <digit>
• A | B | C | D | E | F
• a | b | c | d | e | f

<keyword const>:

• None
• True
• False

<colon list>:

• : [ : ]...

<string lit>:

• [<str prefix>] <short long>

<str prefix>:

• r | u | R | U

<short long>:

• ' [<short item>]... '
• " [<short item>]... "
• ''' [<long item>]... '''
• """ [<long item>]... """

<short item>:

• <short char>
• <escaped str char>

<long item>:

• <long char>
• <escaped str char>

<short char>:

• any source char. except "\", newline, or end quote

<long char>:

• any source char. except "\"

<bytes lit>:

• <byte prefix><shortb longb>

<byte prefix>:  any case/order

• b | br

<shortb longb>:

• ' [<shortb item>]... '
• " [<shortb item>]... "
• ''' [<longb item>]... '''
• """ [<longb item>]... """

<shortb item>:

• <shortb char>
• <escaped char>

<longb item>:

• <longb char>
• <escaped char>

<shortb char>:

• any ASCII char. except "\", newline, or end quote

<longb char>:

• any ASCII char. except "\"

<escaped char>:

• \newline  ignore backslash, newline chars.
• \\  backslash
• \"  double quote
• \'  single quote
• \a  bell
• \b  backspace
• \f  formfeed
• \n  new line
• \r  carriage return
• \t  tab
• \v  vertical tab
• \ooo  octal value = ooo
• \xhh  hex value = hh

<escaped str char>:

• <escaped char>
• \N{name}  Unicode char. = name
• \uxxxx  hex value (16-bit) = xxxx
• \Uxxxxxxxx  hex value (32-bit) = xxxxxxxx

Keyword Switch

When this switch is disabled (enabled by default), many keywords such as {gt, le, set} are instead abbreviated using non-alphanumeric characters: {>, <=, =}.