github.com/sixexorg/magnetic-ring@v0.0.0-20191119090307-31705a21e419/vm/cvm/ast/expr.go (about)

     1  package ast
     2  
     3  import (
     4  	"github.com/sixexorg/magnetic-ring/common/sink"
     5  )
     6  
     7  type Expr interface {
     8  	PositionHolder
     9  	Serialization(sk *sink.ZeroCopySink)
    10  }
    11  
    12  type ExprBase struct {
    13  	Node
    14  }
    15  
    16  /* ConstExprs {{{ */
    17  
    18  type ConstExpr interface {
    19  	Expr
    20  	constExprMarker()
    21  }
    22  
    23  type ConstExprBase struct {
    24  	ExprBase
    25  }
    26  
    27  func (expr *ConstExprBase) constExprMarker() {}
    28  
    29  type TrueExpr struct {
    30  	ConstExprBase
    31  }
    32  
    33  type FalseExpr struct {
    34  	ConstExprBase
    35  }
    36  
    37  type NilExpr struct {
    38  	ConstExprBase
    39  }
    40  
    41  type NumberExpr struct {
    42  	ConstExprBase
    43  
    44  	Value string
    45  }
    46  
    47  type StringExpr struct {
    48  	ConstExprBase
    49  
    50  	Value string
    51  }
    52  
    53  /* ConstExprs }}} */
    54  
    55  type Comma3Expr struct {
    56  	ExprBase
    57  }
    58  
    59  type IdentExpr struct {
    60  	ExprBase
    61  
    62  	Value string
    63  }
    64  
    65  type AttrGetExpr struct {
    66  	ExprBase
    67  
    68  	Object Expr
    69  	Key    Expr
    70  }
    71  
    72  type TableExpr struct {
    73  	ExprBase
    74  
    75  	Fields []*Field
    76  }
    77  
    78  type FuncCallExpr struct {
    79  	ExprBase
    80  
    81  	Func      Expr
    82  	Receiver  Expr
    83  	Method    string
    84  	Args      []Expr
    85  	AdjustRet bool
    86  }
    87  
    88  type LogicalOpExpr struct {
    89  	ExprBase
    90  
    91  	Operator string
    92  	Lhs      Expr
    93  	Rhs      Expr
    94  }
    95  
    96  type RelationalOpExpr struct {
    97  	ExprBase
    98  
    99  	Operator string
   100  	Lhs      Expr
   101  	Rhs      Expr
   102  }
   103  
   104  type StringConcatOpExpr struct {
   105  	ExprBase
   106  
   107  	Lhs Expr
   108  	Rhs Expr
   109  }
   110  
   111  type ArithmeticOpExpr struct {
   112  	ExprBase
   113  
   114  	Operator string
   115  	Lhs      Expr
   116  	Rhs      Expr
   117  }
   118  
   119  type UnaryMinusOpExpr struct {
   120  	ExprBase
   121  	Expr Expr
   122  }
   123  
   124  type UnaryNotOpExpr struct {
   125  	ExprBase
   126  	Expr Expr
   127  }
   128  
   129  type UnaryLenOpExpr struct {
   130  	ExprBase
   131  	Expr Expr
   132  }
   133  
   134  type FunctionExpr struct {
   135  	ExprBase
   136  
   137  	ParList *ParList
   138  	Stmts   []Stmt
   139  }
   140  
   141  const (
   142  	exprTrue           byte = 0x01
   143  	exprFalse          byte = 0x02
   144  	exprNil            byte = 0x03
   145  	exprNumber         byte = 0x04
   146  	exprString         byte = 0x05
   147  	exprComma3         byte = 0x06
   148  	exprIdent          byte = 0x07
   149  	exprAttrGet        byte = 0x08
   150  	exprTable          byte = 0x09
   151  	exprFuncCall       byte = 0x0A
   152  	exprLogicalOp      byte = 0x0B
   153  	exprRelationalOp   byte = 0x0C
   154  	exprStringConcatOp byte = 0x0D
   155  	exprArithmeticOp   byte = 0x0E
   156  	exprUnaryMinusOp   byte = 0x0F
   157  	exprUnaryNotOp     byte = 0x10
   158  	exprUnaryLenOp     byte = 0x11
   159  	exprFunction       byte = 0x12
   160  
   161  	nilReceiver byte = 0x13
   162  )
   163  
   164  func (this *TrueExpr) Serialization(sk *sink.ZeroCopySink) {
   165  	sk.WriteByte(exprTrue)
   166  	sk.WriteVarUint(uint64(this.CodeLine))
   167  	sk.WriteVarUint(uint64(this.CodeLastline))
   168  }
   169  func (this *FalseExpr) Serialization(sk *sink.ZeroCopySink) {
   170  	sk.WriteByte(exprFalse)
   171  	sk.WriteVarUint(uint64(this.CodeLine))
   172  	sk.WriteVarUint(uint64(this.CodeLastline))
   173  }
   174  func (this *NilExpr) Serialization(sk *sink.ZeroCopySink) {
   175  	sk.WriteByte(exprNil)
   176  	sk.WriteVarUint(uint64(this.CodeLine))
   177  	sk.WriteVarUint(uint64(this.CodeLastline))
   178  }
   179  func (this *NumberExpr) Serialization(sk *sink.ZeroCopySink) {
   180  	sk.WriteByte(exprNumber)
   181  	sk.WriteVarUint(uint64(this.CodeLine))
   182  	sk.WriteVarUint(uint64(this.CodeLastline))
   183  	sk.WriteString(this.Value)
   184  }
   185  func (this *StringExpr) Serialization(sk *sink.ZeroCopySink) {
   186  	sk.WriteByte(exprString)
   187  	sk.WriteVarUint(uint64(this.CodeLine))
   188  	sk.WriteVarUint(uint64(this.CodeLastline))
   189  	sk.WriteString(this.Value)
   190  }
   191  func (this *Comma3Expr) Serialization(sk *sink.ZeroCopySink) {
   192  	sk.WriteByte(exprComma3)
   193  	sk.WriteVarUint(uint64(this.CodeLine))
   194  	sk.WriteVarUint(uint64(this.CodeLastline))
   195  }
   196  func (this *IdentExpr) Serialization(sk *sink.ZeroCopySink) {
   197  	sk.WriteByte(exprIdent)
   198  	sk.WriteVarUint(uint64(this.CodeLine))
   199  	sk.WriteVarUint(uint64(this.CodeLastline))
   200  	sk.WriteString(this.Value)
   201  }
   202  func (this *AttrGetExpr) Serialization(sk *sink.ZeroCopySink) {
   203  	sk.WriteByte(exprAttrGet)
   204  	sk.WriteVarUint(uint64(this.CodeLine))
   205  	sk.WriteVarUint(uint64(this.CodeLastline))
   206  	this.Object.Serialization(sk)
   207  	this.Key.Serialization(sk)
   208  }
   209  func (this *TableExpr) Serialization(sk *sink.ZeroCopySink) {
   210  	sk.WriteByte(exprTable)
   211  	sk.WriteVarUint(uint64(this.CodeLine))
   212  	sk.WriteVarUint(uint64(this.CodeLastline))
   213  	sk.WriteVarUint(uint64(len(this.Fields)))
   214  	for _, field := range this.Fields {
   215  		field.Serialization(sk)
   216  	}
   217  }
   218  func (this *FuncCallExpr) Serialization(sk *sink.ZeroCopySink) {
   219  	sk.WriteByte(exprFuncCall)
   220  	sk.WriteVarUint(uint64(this.CodeLine))
   221  	sk.WriteVarUint(uint64(this.CodeLastline))
   222  	this.Func.Serialization(sk)
   223  	if this.Receiver == nil {
   224  		sk.WriteByte(nilReceiver)
   225  	} else {
   226  		this.Receiver.Serialization(sk)
   227  	}
   228  	sk.WriteString(this.Method)
   229  	sk.WriteVarUint(uint64(len(this.Args)))
   230  	for _, arg := range this.Args {
   231  		arg.Serialization(sk)
   232  	}
   233  	sk.WriteBool(this.AdjustRet)
   234  }
   235  func (this *LogicalOpExpr) Serialization(sk *sink.ZeroCopySink) {
   236  	sk.WriteByte(exprLogicalOp)
   237  	sk.WriteVarUint(uint64(this.CodeLine))
   238  	sk.WriteVarUint(uint64(this.CodeLastline))
   239  	sk.WriteString(this.Operator)
   240  	this.Lhs.Serialization(sk)
   241  	this.Rhs.Serialization(sk)
   242  }
   243  func (this *RelationalOpExpr) Serialization(sk *sink.ZeroCopySink) {
   244  	sk.WriteByte(exprRelationalOp)
   245  	sk.WriteVarUint(uint64(this.CodeLine))
   246  	sk.WriteVarUint(uint64(this.CodeLastline))
   247  	sk.WriteString(this.Operator)
   248  	this.Lhs.Serialization(sk)
   249  	this.Rhs.Serialization(sk)
   250  }
   251  func (this *StringConcatOpExpr) Serialization(sk *sink.ZeroCopySink) {
   252  	sk.WriteByte(exprStringConcatOp)
   253  	sk.WriteVarUint(uint64(this.CodeLine))
   254  	sk.WriteVarUint(uint64(this.CodeLastline))
   255  	this.Lhs.Serialization(sk)
   256  	this.Rhs.Serialization(sk)
   257  }
   258  func (this *ArithmeticOpExpr) Serialization(sk *sink.ZeroCopySink) {
   259  	sk.WriteByte(exprArithmeticOp)
   260  	sk.WriteVarUint(uint64(this.CodeLine))
   261  	sk.WriteVarUint(uint64(this.CodeLastline))
   262  	sk.WriteString(this.Operator)
   263  	this.Lhs.Serialization(sk)
   264  	this.Rhs.Serialization(sk)
   265  }
   266  func (this *UnaryMinusOpExpr) Serialization(sk *sink.ZeroCopySink) {
   267  	sk.WriteByte(exprUnaryMinusOp)
   268  	sk.WriteVarUint(uint64(this.CodeLine))
   269  	sk.WriteVarUint(uint64(this.CodeLastline))
   270  	this.Expr.Serialization(sk)
   271  }
   272  func (this *UnaryNotOpExpr) Serialization(sk *sink.ZeroCopySink) {
   273  	sk.WriteByte(exprUnaryNotOp)
   274  	sk.WriteVarUint(uint64(this.CodeLine))
   275  	sk.WriteVarUint(uint64(this.CodeLastline))
   276  	this.Expr.Serialization(sk)
   277  }
   278  func (this *UnaryLenOpExpr) Serialization(sk *sink.ZeroCopySink) {
   279  	sk.WriteByte(exprUnaryLenOp)
   280  	sk.WriteVarUint(uint64(this.CodeLine))
   281  	sk.WriteVarUint(uint64(this.CodeLastline))
   282  	this.Expr.Serialization(sk)
   283  }
   284  func (this *FunctionExpr) Serialization(sk *sink.ZeroCopySink) {
   285  	sk.WriteByte(exprFunction)
   286  	sk.WriteVarUint(uint64(this.CodeLine))
   287  	sk.WriteVarUint(uint64(this.CodeLastline))
   288  	this.ParList.Serialization(sk)
   289  	sk.WriteVarUint(uint64(len(this.Stmts)))
   290  	for _, stmt := range this.Stmts {
   291  		stmt.Serialization(sk)
   292  	}
   293  }
   294  func (this *FunctionExpr) DeSerialization(source *sink.ZeroCopySource) (err error) {
   295  	source.NextByte()
   296  	codeLine, _, _, _ := source.NextVarUint()
   297  	this.SetLine(int(codeLine))
   298  	codeLastLine, _, _, _ := source.NextVarUint()
   299  	this.SetLastLine(int(codeLastLine))
   300  	this.ParList = &ParList{}
   301  	this.ParList.DeSerialization(source)
   302  	length, _, _, _ := source.NextVarUint()
   303  	this.Stmts = make([]Stmt, length)
   304  	var i uint64
   305  	for i = 0; i < length; i++ {
   306  		this.Stmts[i], err = StmtDeserialize(source)
   307  		if err != nil {
   308  			return err
   309  		}
   310  	}
   311  	return nil
   312  }
   313  
   314  func ExprDeserialize(source *sink.ZeroCopySource) (expr Expr, err error) {
   315  
   316  	t, _ := source.NextByte()
   317  	var i uint64
   318  	switch t {
   319  	case exprTrue:
   320  		codeLine, _, _, _ := source.NextVarUint()
   321  		codeLastLine, _, _, _ := source.NextVarUint()
   322  		expr = &TrueExpr{}
   323  		expr.SetLine(int(codeLine))
   324  		expr.SetLastLine(int(codeLastLine))
   325  	case exprFalse:
   326  		expr = &FalseExpr{}
   327  		codeLine, _, _, _ := source.NextVarUint()
   328  		codeLastLine, _, _, _ := source.NextVarUint()
   329  		expr.SetLine(int(codeLine))
   330  		expr.SetLastLine(int(codeLastLine))
   331  	case exprNil:
   332  		expr := &NilExpr{}
   333  		codeLine, _, _, _ := source.NextVarUint()
   334  		codeLastLine, _, _, _ := source.NextVarUint()
   335  		expr.SetLine(int(codeLine))
   336  		expr.SetLastLine(int(codeLastLine))
   337  	case exprNumber:
   338  		codeLine, _, _, _ := source.NextVarUint()
   339  		codeLastLine, _, _, _ := source.NextVarUint()
   340  		v, _, _, _ := source.NextString()
   341  		expr = &NumberExpr{
   342  			Value: v,
   343  		}
   344  		expr.SetLine(int(codeLine))
   345  		expr.SetLastLine(int(codeLastLine))
   346  	case exprString:
   347  		codeLine, _, _, _ := source.NextVarUint()
   348  		codeLastLine, _, _, _ := source.NextVarUint()
   349  		v, _, _, _ := source.NextString()
   350  		expr = &StringExpr{
   351  			Value: v,
   352  		}
   353  		expr.SetLine(int(codeLine))
   354  		expr.SetLastLine(int(codeLastLine))
   355  	case exprComma3:
   356  		expr = &Comma3Expr{}
   357  		codeLine, _, _, _ := source.NextVarUint()
   358  		codeLastLine, _, _, _ := source.NextVarUint()
   359  		expr.SetLine(int(codeLine))
   360  		expr.SetLastLine(int(codeLastLine))
   361  	case exprIdent:
   362  		codeLine, _, _, _ := source.NextVarUint()
   363  		codeLastLine, _, _, _ := source.NextVarUint()
   364  		v, _, _, _ := source.NextString()
   365  		expr = &IdentExpr{
   366  			Value: v,
   367  		}
   368  		expr.SetLine(int(codeLine))
   369  		expr.SetLastLine(int(codeLastLine))
   370  	case exprAttrGet:
   371  		codeLine, _, _, _ := source.NextVarUint()
   372  		codeLastLine, _, _, _ := source.NextVarUint()
   373  		object, err := ExprDeserialize(source)
   374  		if err != nil {
   375  			return nil, err
   376  		}
   377  		key, err := ExprDeserialize(source)
   378  		if err != nil {
   379  			return nil, err
   380  		}
   381  		expr = &AttrGetExpr{Object: object, Key: key}
   382  		expr.SetLine(int(codeLine))
   383  		expr.SetLastLine(int(codeLastLine))
   384  	case exprTable:
   385  		codeLine, _, _, _ := source.NextVarUint()
   386  		codeLastLine, _, _, _ := source.NextVarUint()
   387  		length, _, _, _ := source.NextVarUint()
   388  		fields := make([]*Field, length)
   389  		i = 0
   390  		for i = 0; i < length; i++ {
   391  			fields[i] = &Field{}
   392  			err = fields[i].DeSerialization(source)
   393  			if err != nil {
   394  				return nil, err
   395  			}
   396  		}
   397  		expr = &TableExpr{Fields: fields}
   398  		expr.SetLine(int(codeLine))
   399  		expr.SetLastLine(int(codeLastLine))
   400  	case exprFuncCall:
   401  		codeLine, _, _, _ := source.NextVarUint()
   402  		codeLastLine, _, _, _ := source.NextVarUint()
   403  		f, err := ExprDeserialize(source)
   404  		r, err := ExprDeserialize(source)
   405  		m, _, _, _ := source.NextString()
   406  		length, _, _, _ := source.NextVarUint()
   407  		args := make([]Expr, length)
   408  		i = 0
   409  		for i = 0; i < length; i++ {
   410  			args[i], err = ExprDeserialize(source)
   411  		}
   412  		adjustRet, _, _ := source.NextBool()
   413  		if err != nil {
   414  			return nil, err
   415  		}
   416  		expr = &FuncCallExpr{
   417  			Func:      f,
   418  			Receiver:  r,
   419  			Method:    m,
   420  			Args:      args,
   421  			AdjustRet: adjustRet,
   422  		}
   423  		expr.SetLine(int(codeLine))
   424  		expr.SetLastLine(int(codeLastLine))
   425  	case exprLogicalOp:
   426  		codeLine, _, _, _ := source.NextVarUint()
   427  		codeLastLine, _, _, _ := source.NextVarUint()
   428  		operator, _, _, _ := source.NextString()
   429  		lhs, err := ExprDeserialize(source)
   430  		if err != nil {
   431  			return nil, err
   432  		}
   433  		rhs, err := ExprDeserialize(source)
   434  		if err != nil {
   435  			return nil, err
   436  		}
   437  		expr = &LogicalOpExpr{Operator: operator, Lhs: lhs, Rhs: rhs}
   438  		expr.SetLine(int(codeLine))
   439  		expr.SetLastLine(int(codeLastLine))
   440  	case exprRelationalOp:
   441  		codeLine, _, _, _ := source.NextVarUint()
   442  		codeLastLine, _, _, _ := source.NextVarUint()
   443  		operator, _, _, _ := source.NextString()
   444  		lhs, err := ExprDeserialize(source)
   445  		if err != nil {
   446  			return nil, err
   447  		}
   448  		rhs, err := ExprDeserialize(source)
   449  		if err != nil {
   450  			return nil, err
   451  		}
   452  		expr = &RelationalOpExpr{Operator: operator, Lhs: lhs, Rhs: rhs}
   453  		expr.SetLine(int(codeLine))
   454  		expr.SetLastLine(int(codeLastLine))
   455  	case exprStringConcatOp:
   456  		codeLine, _, _, _ := source.NextVarUint()
   457  		codeLastLine, _, _, _ := source.NextVarUint()
   458  		lhs, err := ExprDeserialize(source)
   459  		if err != nil {
   460  			return nil, err
   461  		}
   462  		rhs, err := ExprDeserialize(source)
   463  		if err != nil {
   464  			return nil, err
   465  		}
   466  		expr = &StringConcatOpExpr{Lhs: lhs, Rhs: rhs}
   467  		expr.SetLine(int(codeLine))
   468  		expr.SetLastLine(int(codeLastLine))
   469  	case exprArithmeticOp:
   470  		codeLine, _, _, _ := source.NextVarUint()
   471  		codeLastLine, _, _, _ := source.NextVarUint()
   472  		operator, _, _, _ := source.NextString()
   473  		lhs, err := ExprDeserialize(source)
   474  		if err != nil {
   475  			return nil, err
   476  		}
   477  		rhs, err := ExprDeserialize(source)
   478  		if err != nil {
   479  			return nil, err
   480  		}
   481  		expr := &ArithmeticOpExpr{Operator: operator, Lhs: lhs, Rhs: rhs}
   482  		expr.SetLine(int(codeLine))
   483  		expr.SetLastLine(int(codeLastLine))
   484  	case exprUnaryMinusOp:
   485  		codeLine, _, _, _ := source.NextVarUint()
   486  		codeLastLine, _, _, _ := source.NextVarUint()
   487  		e, err := ExprDeserialize(source)
   488  		if err != nil {
   489  			return nil, err
   490  		}
   491  		expr := &UnaryMinusOpExpr{Expr: e}
   492  		expr.SetLine(int(codeLine))
   493  		expr.SetLastLine(int(codeLastLine))
   494  	case exprUnaryNotOp:
   495  		codeLine, _, _, _ := source.NextVarUint()
   496  		codeLastLine, _, _, _ := source.NextVarUint()
   497  		e, err := ExprDeserialize(source)
   498  		if err != nil {
   499  			return nil, err
   500  		}
   501  		expr = &UnaryNotOpExpr{Expr: e}
   502  		expr.SetLine(int(codeLine))
   503  		expr.SetLastLine(int(codeLastLine))
   504  	case exprUnaryLenOp:
   505  		codeLine, _, _, _ := source.NextVarUint()
   506  		codeLastLine, _, _, _ := source.NextVarUint()
   507  		e, err := ExprDeserialize(source)
   508  		if err != nil {
   509  			return nil, err
   510  		}
   511  		expr = &UnaryLenOpExpr{Expr: e}
   512  		expr.SetLine(int(codeLine))
   513  		expr.SetLastLine(int(codeLastLine))
   514  	case exprFunction:
   515  		codeLine, _, _, _ := source.NextVarUint()
   516  		codeLastLine, _, _, _ := source.NextVarUint()
   517  		parList := &ParList{}
   518  		parList.DeSerialization(source)
   519  		length, _, _, _ := source.NextVarUint()
   520  		stmts := make([]Stmt, length)
   521  		i = 0
   522  		for i = 0; i < length; i++ {
   523  			stmts[i], err = StmtDeserialize(source)
   524  			if err != nil {
   525  				return nil, err
   526  			}
   527  		}
   528  		expr = &FunctionExpr{ParList: parList, Stmts: stmts}
   529  		expr.SetLine(int(codeLine))
   530  		expr.SetLastLine(int(codeLastLine))
   531  	case nilReceiver:
   532  		expr = nil
   533  	}
   534  	return expr, nil
   535  }