+++ /dev/null
-package compiler
-
-import (
- "bytes"
- "encoding/hex"
- "fmt"
- "strconv"
- "unicode"
-)
-
-// We have some function naming conventions.
-//
-// For terminals:
-// scanX takes buf and position, returns new position (and maybe a value)
-// peekX takes *parser, returns bool or string
-// consumeX takes *parser and maybe a required literal, maybe returns value
-// also updates the parser position
-//
-// For nonterminals:
-// parseX takes *parser, returns AST node, updates parser position
-
-type parser struct {
- buf []byte
- pos int
-}
-
-func (p *parser) errorf(format string, args ...interface{}) {
- panic(parserErr{buf: p.buf, offset: p.pos, format: format, args: args})
-}
-
-// parse is the main entry point to the parser
-func parse(buf []byte) (contracts []*Contract, err error) {
- defer func() {
- if val := recover(); val != nil {
- if e, ok := val.(parserErr); ok {
- err = e
- } else {
- panic(val)
- }
- }
- }()
- p := &parser{buf: buf}
- contracts = parseContracts(p)
- return
-}
-
-// parse functions
-
-func parseContracts(p *parser) []*Contract {
- var result []*Contract
- if pos := scanKeyword(p.buf, p.pos, "contract"); pos < 0 {
- p.errorf("expected contract")
- }
-
- for peekKeyword(p) == "contract" {
- contract := parseContract(p)
- result = append(result, contract)
- }
- return result
-}
-
-// contract name(p1, p2: t1, p3: t2) locks value { ... }
-func parseContract(p *parser) *Contract {
- consumeKeyword(p, "contract")
- name := consumeIdentifier(p)
- params := parseParams(p)
- // locks amount of asset
- consumeKeyword(p, "locks")
- value := ValueInfo{}
- value.Amount = consumeIdentifier(p)
- consumeKeyword(p, "of")
- value.Asset = consumeIdentifier(p)
- consumeTok(p, "{")
- clauses := parseClauses(p)
- consumeTok(p, "}")
- return &Contract{Name: name, Params: params, Clauses: clauses, Value: value}
-}
-
-// (p1, p2: t1, p3: t2)
-func parseParams(p *parser) []*Param {
- var params []*Param
- consumeTok(p, "(")
- first := true
- for !peekTok(p, ")") {
- if first {
- first = false
- } else {
- consumeTok(p, ",")
- }
- pt := parseParamsType(p)
- params = append(params, pt...)
- }
- consumeTok(p, ")")
- return params
-}
-
-func parseClauses(p *parser) []*Clause {
- var clauses []*Clause
- for !peekTok(p, "}") {
- c := parseClause(p)
- clauses = append(clauses, c)
- }
- return clauses
-}
-
-func parseParamsType(p *parser) []*Param {
- firstName := consumeIdentifier(p)
- params := []*Param{&Param{Name: firstName}}
- for peekTok(p, ",") {
- consumeTok(p, ",")
- name := consumeIdentifier(p)
- params = append(params, &Param{Name: name})
- }
- consumeTok(p, ":")
- typ := consumeIdentifier(p)
- for _, parm := range params {
- if tdesc, ok := types[typ]; ok {
- parm.Type = tdesc
- } else {
- p.errorf("unknown type %s", typ)
- }
- }
- return params
-}
-
-func parseClause(p *parser) *Clause {
- var c Clause
- consumeKeyword(p, "clause")
- c.Name = consumeIdentifier(p)
- c.Params = parseParams(p)
- consumeTok(p, "{")
- c.statements = parseStatements(p)
- consumeTok(p, "}")
- return &c
-}
-
-func parseStatements(p *parser) []statement {
- var statements []statement
- for !peekTok(p, "}") {
- s := parseStatement(p)
- statements = append(statements, s)
- }
- return statements
-}
-
-func parseStatement(p *parser) statement {
- switch peekKeyword(p) {
- case "if":
- return parseIfStmt(p)
- case "define":
- return parseDefineStmt(p)
- case "assign":
- return parseAssignStmt(p)
- case "verify":
- return parseVerifyStmt(p)
- case "lock":
- return parseLockStmt(p)
- case "unlock":
- return parseUnlockStmt(p)
- }
- panic(parseErr(p.buf, p.pos, "unknown keyword \"%s\"", peekKeyword(p)))
-}
-
-func parseIfStmt(p *parser) *ifStatement {
- consumeKeyword(p, "if")
- condition := parseExpr(p)
- body := &IfStatmentBody{}
- consumeTok(p, "{")
- body.trueBody = parseStatements(p)
- consumeTok(p, "}")
- if peekKeyword(p) == "else" {
- consumeKeyword(p, "else")
- consumeTok(p, "{")
- body.falseBody = parseStatements(p)
- consumeTok(p, "}")
- }
- return &ifStatement{condition: condition, body: body}
-}
-
-func parseDefineStmt(p *parser) *defineStatement {
- defineStat := &defineStatement{}
- consumeKeyword(p, "define")
- param := &Param{}
- param.Name = consumeIdentifier(p)
- consumeTok(p, ":")
- variableType := consumeIdentifier(p)
- if tdesc, ok := types[variableType]; ok {
- param.Type = tdesc
- } else {
- p.errorf("unknown type %s", variableType)
- }
- defineStat.variable = param
- if peekTok(p, "=") {
- consumeTok(p, "=")
- defineStat.expr = parseExpr(p)
- }
- return defineStat
-}
-
-func parseAssignStmt(p *parser) *assignStatement {
- consumeKeyword(p, "assign")
- varName := consumeIdentifier(p)
- consumeTok(p, "=")
- expr := parseExpr(p)
- return &assignStatement{variable: &Param{Name: varName}, expr: expr}
-}
-
-func parseVerifyStmt(p *parser) *verifyStatement {
- consumeKeyword(p, "verify")
- expr := parseExpr(p)
- return &verifyStatement{expr: expr}
-}
-
-func parseLockStmt(p *parser) *lockStatement {
- consumeKeyword(p, "lock")
- lockedAmount := parseExpr(p)
- consumeKeyword(p, "of")
- lockedAsset := parseExpr(p)
- consumeKeyword(p, "with")
- program := parseExpr(p)
- return &lockStatement{lockedAmount: lockedAmount, lockedAsset: lockedAsset, program: program}
-}
-
-func parseUnlockStmt(p *parser) *unlockStatement {
- consumeKeyword(p, "unlock")
- unlockedAmount := parseExpr(p)
- consumeKeyword(p, "of")
- unlockedAsset := parseExpr(p)
- return &unlockStatement{unlockedAmount: unlockedAmount, unlockedAsset: unlockedAsset}
-}
-
-func parseExpr(p *parser) expression {
- // Uses the precedence-climbing algorithm
- // <https://en.wikipedia.org/wiki/Operator-precedence_parser#Precedence_climbing_method>
- expr := parseUnaryExpr(p)
- expr2, pos := parseExprCont(p, expr, 0)
- if pos < 0 {
- p.errorf("expected expression")
- }
- p.pos = pos
- return expr2
-}
-
-func parseUnaryExpr(p *parser) expression {
- op, pos := scanUnaryOp(p.buf, p.pos)
- if pos < 0 {
- return parseExpr2(p)
- }
- p.pos = pos
- expr := parseUnaryExpr(p)
- return &unaryExpr{op: op, expr: expr}
-}
-
-func parseExprCont(p *parser, lhs expression, minPrecedence int) (expression, int) {
- for {
- op, pos := scanBinaryOp(p.buf, p.pos)
- if pos < 0 || op.precedence < minPrecedence {
- break
- }
- p.pos = pos
-
- rhs := parseUnaryExpr(p)
-
- for {
- op2, pos2 := scanBinaryOp(p.buf, p.pos)
- if pos2 < 0 || op2.precedence <= op.precedence {
- break
- }
- rhs, p.pos = parseExprCont(p, rhs, op2.precedence)
- if p.pos < 0 {
- return nil, -1 // or is this an error?
- }
- }
- lhs = &binaryExpr{left: lhs, right: rhs, op: op}
- }
- return lhs, p.pos
-}
-
-func parseExpr2(p *parser) expression {
- if expr, pos := scanLiteralExpr(p.buf, p.pos); pos >= 0 {
- p.pos = pos
- return expr
- }
- return parseExpr3(p)
-}
-
-func parseExpr3(p *parser) expression {
- e := parseExpr4(p)
- if peekTok(p, "(") {
- args := parseArgs(p)
- return &callExpr{fn: e, args: args}
- }
- return e
-}
-
-func parseExpr4(p *parser) expression {
- if peekTok(p, "(") {
- consumeTok(p, "(")
- e := parseExpr(p)
- consumeTok(p, ")")
- return e
- }
- if peekTok(p, "[") {
- var elts []expression
- consumeTok(p, "[")
- first := true
- for !peekTok(p, "]") {
- if first {
- first = false
- } else {
- consumeTok(p, ",")
- }
- e := parseExpr(p)
- elts = append(elts, e)
- }
- consumeTok(p, "]")
- return listExpr(elts)
- }
- name := consumeIdentifier(p)
- return varRef(name)
-}
-
-func parseArgs(p *parser) []expression {
- var exprs []expression
- consumeTok(p, "(")
- first := true
- for !peekTok(p, ")") {
- if first {
- first = false
- } else {
- consumeTok(p, ",")
- }
- e := parseExpr(p)
- exprs = append(exprs, e)
- }
- consumeTok(p, ")")
- return exprs
-}
-
-// peek functions
-
-func peekKeyword(p *parser) string {
- name, _ := scanIdentifier(p.buf, p.pos)
- return name
-}
-
-func peekTok(p *parser, token string) bool {
- pos := scanTok(p.buf, p.pos, token)
- return pos >= 0
-}
-
-// consume functions
-
-var keywords = []string{
- "contract", "clause", "verify", "locks", "of",
- "lock", "with", "unlock", "if", "else",
- "define", "assign", "true", "false",
-}
-
-func consumeKeyword(p *parser, keyword string) {
- pos := scanKeyword(p.buf, p.pos, keyword)
- if pos < 0 {
- p.errorf("expected keyword %s", keyword)
- }
- p.pos = pos
-}
-
-func consumeIdentifier(p *parser) string {
- name, pos := scanIdentifier(p.buf, p.pos)
- if pos < 0 {
- p.errorf("expected identifier")
- }
- p.pos = pos
- return name
-}
-
-func consumeTok(p *parser, token string) {
- pos := scanTok(p.buf, p.pos, token)
- if pos < 0 {
- p.errorf("expected %s token", token)
- }
- p.pos = pos
-}
-
-// scan functions
-
-func scanUnaryOp(buf []byte, offset int) (*unaryOp, int) {
- // Maximum munch. Make sure "-3" scans as ("-3"), not ("-", "3").
- if _, pos := scanIntLiteral(buf, offset); pos >= 0 {
- return nil, -1
- }
- for _, op := range unaryOps {
- newOffset := scanTok(buf, offset, op.op)
- if newOffset >= 0 {
- return &op, newOffset
- }
- }
- return nil, -1
-}
-
-func scanBinaryOp(buf []byte, offset int) (*binaryOp, int) {
- offset = skipWsAndComments(buf, offset)
- var (
- found *binaryOp
- newOffset = -1
- )
- for i, op := range binaryOps {
- offset2 := scanTok(buf, offset, op.op)
- if offset2 >= 0 {
- if found == nil || len(op.op) > len(found.op) {
- found = &binaryOps[i]
- newOffset = offset2
- }
- }
- }
- return found, newOffset
-}
-
-// TODO(bobg): boolean literals?
-func scanLiteralExpr(buf []byte, offset int) (expression, int) {
- offset = skipWsAndComments(buf, offset)
- intliteral, newOffset := scanIntLiteral(buf, offset)
- if newOffset >= 0 {
- return intliteral, newOffset
- }
- strliteral, newOffset := scanStrLiteral(buf, offset)
- if newOffset >= 0 {
- return strliteral, newOffset
- }
- bytesliteral, newOffset := scanBytesLiteral(buf, offset) // 0x6c249a...
- if newOffset >= 0 {
- return bytesliteral, newOffset
- }
- booleanLiteral, newOffset := scanBoolLiteral(buf, offset) // true or false
- if newOffset >= 0 {
- return booleanLiteral, newOffset
- }
- return nil, -1
-}
-
-func scanIdentifier(buf []byte, offset int) (string, int) {
- offset = skipWsAndComments(buf, offset)
- i := offset
- for ; i < len(buf) && isIDChar(buf[i], i == offset); i++ {
- }
- if i == offset {
- return "", -1
- }
- return string(buf[offset:i]), i
-}
-
-func scanTok(buf []byte, offset int, s string) int {
- offset = skipWsAndComments(buf, offset)
- prefix := []byte(s)
- if bytes.HasPrefix(buf[offset:], prefix) {
- return offset + len(prefix)
- }
- return -1
-}
-
-func scanKeyword(buf []byte, offset int, keyword string) int {
- id, newOffset := scanIdentifier(buf, offset)
- if newOffset < 0 {
- return -1
- }
- if id != keyword {
- return -1
- }
- return newOffset
-}
-
-func scanIntLiteral(buf []byte, offset int) (integerLiteral, int) {
- offset = skipWsAndComments(buf, offset)
- start := offset
- if offset < len(buf) && buf[offset] == '-' {
- offset++
- }
- i := offset
- for ; i < len(buf) && unicode.IsDigit(rune(buf[i])); i++ {
- // the literal is BytesLiteral when it starts with 0x/0X
- if buf[i] == '0' && i < len(buf)-1 && (buf[i+1] == 'x' || buf[i+1] == 'X') {
- return 0, -1
- }
- }
- if i > offset {
- n, err := strconv.ParseInt(string(buf[start:i]), 10, 64)
- if err != nil {
- return 0, -1
- }
- return integerLiteral(n), i
- }
- return 0, -1
-}
-
-func scanStrLiteral(buf []byte, offset int) (bytesLiteral, int) {
- offset = skipWsAndComments(buf, offset)
- if offset >= len(buf) || buf[offset] != '\'' {
- return bytesLiteral{}, -1
- }
- var byteBuf bytesLiteral
- for i := offset + 1; i < len(buf); i++ {
- if buf[i] == '\'' {
- return byteBuf, i + 1
- }
- if buf[i] == '\\' && i < len(buf)-1 {
- if c, ok := scanEscape(buf[i+1]); ok {
- byteBuf = append(byteBuf, c)
- i++
- continue
- }
- }
- byteBuf = append(byteBuf, buf[i])
- }
- panic(parseErr(buf, offset, "unterminated string literal"))
-}
-
-func scanBytesLiteral(buf []byte, offset int) (bytesLiteral, int) {
- offset = skipWsAndComments(buf, offset)
- if offset+4 >= len(buf) {
- return nil, -1
- }
- if buf[offset] != '0' || (buf[offset+1] != 'x' && buf[offset+1] != 'X') {
- return nil, -1
- }
- if !isHexDigit(buf[offset+2]) || !isHexDigit(buf[offset+3]) {
- return nil, -1
- }
- i := offset + 4
- for ; i < len(buf); i += 2 {
- if i == len(buf)-1 {
- panic(parseErr(buf, offset, "odd number of digits in hex literal"))
- }
- if !isHexDigit(buf[i]) {
- break
- }
- if !isHexDigit(buf[i+1]) {
- panic(parseErr(buf, offset, "odd number of digits in hex literal"))
- }
- }
- decoded := make([]byte, hex.DecodedLen(i-(offset+2)))
- _, err := hex.Decode(decoded, buf[offset+2:i])
- if err != nil {
- return bytesLiteral{}, -1
- }
- return bytesLiteral(decoded), i
-}
-
-func scanBoolLiteral(buf []byte, offset int) (booleanLiteral, int) {
- offset = skipWsAndComments(buf, offset)
- if offset >= len(buf) {
- return false, -1
- }
-
- newOffset := scanKeyword(buf, offset, "true")
- if newOffset < 0 {
- if newOffset = scanKeyword(buf, offset, "false"); newOffset < 0 {
- return false, -1
- }
- return false, newOffset
- }
- return true, newOffset
-}
-
-func skipWsAndComments(buf []byte, offset int) int {
- var inComment bool
- for ; offset < len(buf); offset++ {
- c := buf[offset]
- if inComment {
- if c == '\n' {
- inComment = false
- }
- } else {
- if c == '/' && offset < len(buf)-1 && buf[offset+1] == '/' {
- inComment = true
- offset++ // skip two chars instead of one
- } else if !unicode.IsSpace(rune(c)) {
- break
- }
- }
- }
- return offset
-}
-
-func isHexDigit(b byte) bool {
- return (b >= '0' && b <= '9') || (b >= 'a' && b <= 'f') || (b >= 'A' && b <= 'F')
-}
-
-func isIDChar(c byte, initial bool) bool {
- if c >= 'a' && c <= 'z' {
- return true
- }
- if c >= 'A' && c <= 'Z' {
- return true
- }
- if c == '_' {
- return true
- }
- if initial {
- return false
- }
- return unicode.IsDigit(rune(c))
-}
-
-type parserErr struct {
- buf []byte
- offset int
- format string
- args []interface{}
-}
-
-func parseErr(buf []byte, offset int, format string, args ...interface{}) error {
- return parserErr{buf: buf, offset: offset, format: format, args: args}
-}
-
-func (p parserErr) Error() string {
- // Lines start at 1, columns start at 0, like nature intended.
- line := 1
- col := 0
- for i := 0; i < p.offset; i++ {
- if p.buf[i] == '\n' {
- line++
- col = 0
- } else {
- col++
- }
- }
- args := []interface{}{line, col}
- args = append(args, p.args...)
- return fmt.Sprintf("line %d, col %d: "+p.format, args...)
-}
-
-func scanEscape(c byte) (byte, bool) {
- escapeFlag := true
- switch c {
- case '\'', '"', '\\':
- case 'b':
- c = '\b'
- case 'f':
- c = '\f'
- case 'n':
- c = '\n'
- case 'r':
- c = '\r'
- case 't':
- c = '\t'
- case 'v':
- c = '\v'
- default:
- escapeFlag = false
- }
- return c, escapeFlag
-}
OSDN Git Service
