11 // We have some function naming conventions.
14 // scanX takes buf and position, returns new position (and maybe a value)
15 // peekX takes *parser, returns bool or string
16 // consumeX takes *parser and maybe a required literal, maybe returns value
17 // also updates the parser position
20 // parseX takes *parser, returns AST node, updates parser position
27 func (p *parser) errorf(format string, args ...interface{}) {
28 panic(parserErr{buf: p.buf, offset: p.pos, format: format, args: args})
31 // parse is the main entry point to the parser
32 func parse(buf []byte) (contracts []*Contract, err error) {
34 if val := recover(); val != nil {
35 if e, ok := val.(parserErr); ok {
42 p := &parser{buf: buf}
43 contracts = parseContracts(p)
49 func parseContracts(p *parser) []*Contract {
50 var result []*Contract
51 for peekKeyword(p) == "contract" {
52 contract := parseContract(p)
53 result = append(result, contract)
58 // contract name(p1, p2: t1, p3: t2) locks value { ... }
59 func parseContract(p *parser) *Contract {
60 consumeKeyword(p, "contract")
61 name := consumeIdentifier(p)
62 params := parseParams(p)
63 // locks amount of asset
64 consumeKeyword(p, "locks")
66 value.Amount = consumeIdentifier(p)
67 consumeKeyword(p, "of")
68 value.Asset = consumeIdentifier(p)
70 clauses := parseClauses(p)
72 return &Contract{Name: name, Params: params, Clauses: clauses, Value: value}
75 // (p1, p2: t1, p3: t2)
76 func parseParams(p *parser) []*Param {
80 for !peekTok(p, ")") {
86 pt := parseParamsType(p)
87 params = append(params, pt...)
93 func parseClauses(p *parser) []*Clause {
95 for !peekTok(p, "}") {
97 clauses = append(clauses, c)
102 func parseParamsType(p *parser) []*Param {
103 firstName := consumeIdentifier(p)
104 params := []*Param{&Param{Name: firstName}}
105 for peekTok(p, ",") {
107 name := consumeIdentifier(p)
108 params = append(params, &Param{Name: name})
111 typ := consumeIdentifier(p)
112 for _, parm := range params {
113 if tdesc, ok := types[typ]; ok {
116 p.errorf("unknown type %s", typ)
122 func parseClause(p *parser) *Clause {
124 consumeKeyword(p, "clause")
125 c.Name = consumeIdentifier(p)
126 c.Params = parseParams(p)
128 c.statements = parseStatements(p)
133 func parseStatements(p *parser) []statement {
134 var statements []statement
135 for !peekTok(p, "}") {
136 s := parseStatement(p)
137 statements = append(statements, s)
142 func parseStatement(p *parser) statement {
143 switch peekKeyword(p) {
145 return parseIfStmt(p)
147 return parseDefineStmt(p)
149 return parseAssignStmt(p)
151 return parseVerifyStmt(p)
153 return parseLockStmt(p)
155 return parseUnlockStmt(p)
157 panic(parseErr(p.buf, p.pos, "unknown keyword \"%s\"", peekKeyword(p)))
160 func parseIfStmt(p *parser) *ifStatement {
161 consumeKeyword(p, "if")
162 condition := parseExpr(p)
163 body := &IfStatmentBody{}
165 body.trueBody = parseStatements(p)
167 if peekKeyword(p) == "else" {
168 consumeKeyword(p, "else")
170 body.falseBody = parseStatements(p)
173 return &ifStatement{condition: condition, body: body}
176 func parseDefineStmt(p *parser) *defineStatement {
177 defineStat := &defineStatement{}
178 consumeKeyword(p, "define")
180 param.Name = consumeIdentifier(p)
182 variableType := consumeIdentifier(p)
183 if tdesc, ok := types[variableType]; ok {
186 p.errorf("unknown type %s", variableType)
188 defineStat.variable = param
191 defineStat.expr = parseExpr(p)
196 func parseAssignStmt(p *parser) *assignStatement {
197 consumeKeyword(p, "assign")
198 varName := consumeIdentifier(p)
201 return &assignStatement{variable: &Param{Name: varName}, expr: expr}
204 func parseVerifyStmt(p *parser) *verifyStatement {
205 consumeKeyword(p, "verify")
207 return &verifyStatement{expr: expr}
210 func parseLockStmt(p *parser) *lockStatement {
211 consumeKeyword(p, "lock")
212 lockedAmount := parseExpr(p)
213 consumeKeyword(p, "of")
214 lockedAsset := parseExpr(p)
215 consumeKeyword(p, "with")
216 program := parseExpr(p)
217 return &lockStatement{lockedAmount: lockedAmount, lockedAsset: lockedAsset, program: program}
220 func parseUnlockStmt(p *parser) *unlockStatement {
221 consumeKeyword(p, "unlock")
222 unlockedAmount := parseExpr(p)
223 consumeKeyword(p, "of")
224 unlockedAsset := parseExpr(p)
225 return &unlockStatement{unlockedAmount: unlockedAmount, unlockedAsset: unlockedAsset}
228 func parseExpr(p *parser) expression {
229 // Uses the precedence-climbing algorithm
230 // <https://en.wikipedia.org/wiki/Operator-precedence_parser#Precedence_climbing_method>
231 expr := parseUnaryExpr(p)
232 expr2, pos := parseExprCont(p, expr, 0)
234 p.errorf("expected expression")
240 func parseUnaryExpr(p *parser) expression {
241 op, pos := scanUnaryOp(p.buf, p.pos)
246 expr := parseUnaryExpr(p)
247 return &unaryExpr{op: op, expr: expr}
250 func parseExprCont(p *parser, lhs expression, minPrecedence int) (expression, int) {
252 op, pos := scanBinaryOp(p.buf, p.pos)
253 if pos < 0 || op.precedence < minPrecedence {
258 rhs := parseUnaryExpr(p)
261 op2, pos2 := scanBinaryOp(p.buf, p.pos)
262 if pos2 < 0 || op2.precedence <= op.precedence {
265 rhs, p.pos = parseExprCont(p, rhs, op2.precedence)
267 return nil, -1 // or is this an error?
270 lhs = &binaryExpr{left: lhs, right: rhs, op: op}
275 func parseExpr2(p *parser) expression {
276 if expr, pos := scanLiteralExpr(p.buf, p.pos); pos >= 0 {
283 func parseExpr3(p *parser) expression {
287 return &callExpr{fn: e, args: args}
292 func parseExpr4(p *parser) expression {
300 var elts []expression
303 for !peekTok(p, "]") {
310 elts = append(elts, e)
313 return listExpr(elts)
315 name := consumeIdentifier(p)
319 func parseArgs(p *parser) []expression {
320 var exprs []expression
323 for !peekTok(p, ")") {
330 exprs = append(exprs, e)
338 func peekKeyword(p *parser) string {
339 name, _ := scanIdentifier(p.buf, p.pos)
343 func peekTok(p *parser, token string) bool {
344 pos := scanTok(p.buf, p.pos, token)
350 var keywords = []string{
351 "contract", "clause", "verify", "locks", "of",
352 "lock", "with", "unlock", "if", "else",
353 "define", "assign", "true", "false",
356 func consumeKeyword(p *parser, keyword string) {
357 pos := scanKeyword(p.buf, p.pos, keyword)
359 p.errorf("expected keyword %s", keyword)
364 func consumeIdentifier(p *parser) string {
365 name, pos := scanIdentifier(p.buf, p.pos)
367 p.errorf("expected identifier")
373 func consumeTok(p *parser, token string) {
374 pos := scanTok(p.buf, p.pos, token)
376 p.errorf("expected %s token", token)
383 func scanUnaryOp(buf []byte, offset int) (*unaryOp, int) {
384 // Maximum munch. Make sure "-3" scans as ("-3"), not ("-", "3").
385 if _, pos := scanIntLiteral(buf, offset); pos >= 0 {
388 for _, op := range unaryOps {
389 newOffset := scanTok(buf, offset, op.op)
391 return &op, newOffset
397 func scanBinaryOp(buf []byte, offset int) (*binaryOp, int) {
398 offset = skipWsAndComments(buf, offset)
403 for i, op := range binaryOps {
404 offset2 := scanTok(buf, offset, op.op)
406 if found == nil || len(op.op) > len(found.op) {
407 found = &binaryOps[i]
412 return found, newOffset
415 // TODO(bobg): boolean literals?
416 func scanLiteralExpr(buf []byte, offset int) (expression, int) {
417 offset = skipWsAndComments(buf, offset)
418 intliteral, newOffset := scanIntLiteral(buf, offset)
420 return intliteral, newOffset
422 strliteral, newOffset := scanStrLiteral(buf, offset)
424 return strliteral, newOffset
426 bytesliteral, newOffset := scanBytesLiteral(buf, offset) // 0x6c249a...
428 return bytesliteral, newOffset
430 booleanLiteral, newOffset := scanBoolLiteral(buf, offset) // true or false
432 return booleanLiteral, newOffset
437 func scanIdentifier(buf []byte, offset int) (string, int) {
438 offset = skipWsAndComments(buf, offset)
440 for ; i < len(buf) && isIDChar(buf[i], i == offset); i++ {
445 return string(buf[offset:i]), i
448 func scanTok(buf []byte, offset int, s string) int {
449 offset = skipWsAndComments(buf, offset)
451 if bytes.HasPrefix(buf[offset:], prefix) {
452 return offset + len(prefix)
457 func scanKeyword(buf []byte, offset int, keyword string) int {
458 id, newOffset := scanIdentifier(buf, offset)
468 func scanIntLiteral(buf []byte, offset int) (integerLiteral, int) {
469 offset = skipWsAndComments(buf, offset)
471 if offset < len(buf) && buf[offset] == '-' {
475 for ; i < len(buf) && unicode.IsDigit(rune(buf[i])); i++ {
476 // the literal is BytesLiteral when it starts with 0x/0X
477 if buf[i] == '0' && i < len(buf)-1 && (buf[i+1] == 'x' || buf[i+1] == 'X') {
482 n, err := strconv.ParseInt(string(buf[start:i]), 10, 64)
486 return integerLiteral(n), i
491 func scanStrLiteral(buf []byte, offset int) (bytesLiteral, int) {
492 offset = skipWsAndComments(buf, offset)
493 if offset >= len(buf) || buf[offset] != '\'' {
494 return bytesLiteral{}, -1
496 var byteBuf bytesLiteral
497 for i := offset + 1; i < len(buf); i++ {
499 return byteBuf, i + 1
501 if buf[i] == '\\' && i < len(buf)-1 {
502 if c, ok := scanEscape(buf[i+1]); ok {
503 byteBuf = append(byteBuf, c)
508 byteBuf = append(byteBuf, buf[i])
510 panic(parseErr(buf, offset, "unterminated string literal"))
513 func scanBytesLiteral(buf []byte, offset int) (bytesLiteral, int) {
514 offset = skipWsAndComments(buf, offset)
515 if offset+4 >= len(buf) {
518 if buf[offset] != '0' || (buf[offset+1] != 'x' && buf[offset+1] != 'X') {
521 if !isHexDigit(buf[offset+2]) || !isHexDigit(buf[offset+3]) {
525 for ; i < len(buf); i += 2 {
527 panic(parseErr(buf, offset, "odd number of digits in hex literal"))
529 if !isHexDigit(buf[i]) {
532 if !isHexDigit(buf[i+1]) {
533 panic(parseErr(buf, offset, "odd number of digits in hex literal"))
536 decoded := make([]byte, hex.DecodedLen(i-(offset+2)))
537 _, err := hex.Decode(decoded, buf[offset+2:i])
539 return bytesLiteral{}, -1
541 return bytesLiteral(decoded), i
544 func scanBoolLiteral(buf []byte, offset int) (booleanLiteral, int) {
545 offset = skipWsAndComments(buf, offset)
546 if offset >= len(buf) {
550 newOffset := scanKeyword(buf, offset, "true")
552 if newOffset = scanKeyword(buf, offset, "false"); newOffset < 0 {
555 return false, newOffset
557 return true, newOffset
560 func skipWsAndComments(buf []byte, offset int) int {
562 for ; offset < len(buf); offset++ {
569 if c == '/' && offset < len(buf)-1 && buf[offset+1] == '/' {
571 offset++ // skip two chars instead of one
572 } else if !unicode.IsSpace(rune(c)) {
580 func isHexDigit(b byte) bool {
581 return (b >= '0' && b <= '9') || (b >= 'a' && b <= 'f') || (b >= 'A' && b <= 'F')
584 func isIDChar(c byte, initial bool) bool {
585 if c >= 'a' && c <= 'z' {
588 if c >= 'A' && c <= 'Z' {
597 return unicode.IsDigit(rune(c))
600 type parserErr struct {
607 func parseErr(buf []byte, offset int, format string, args ...interface{}) error {
608 return parserErr{buf: buf, offset: offset, format: format, args: args}
611 func (p parserErr) Error() string {
612 // Lines start at 1, columns start at 0, like nature intended.
615 for i := 0; i < p.offset; i++ {
616 if p.buf[i] == '\n' {
623 args := []interface{}{line, col}
624 args = append(args, p.args...)
625 return fmt.Sprintf("line %d, col %d: "+p.format, args...)
628 func scanEscape(c byte) (byte, bool) {
631 case '\'', '"', '\\':