github.com/ontio/ontology@v1.14.4/vm/neovm/value_stack_conversion.go (about)

     1  /*
     2   * Copyright (C) 2018 The ontology Authors
     3   * This file is part of The ontology library.
     4   *
     5   * The ontology is free software: you can redistribute it and/or modify
     6   * it under the terms of the GNU Lesser General Public License as published by
     7   * the Free Software Foundation, either version 3 of the License, or
     8   * (at your option) any later version.
     9   *
    10   * The ontology is distributed in the hope that it will be useful,
    11   * but WITHOUT ANY WARRANTY; without even the implied warranty of
    12   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    13   * GNU Lesser General Public License for more details.
    14   *
    15   * You should have received a copy of the GNU Lesser General Public License
    16   * along with The ontology.  If not, see <http://www.gnu.org/licenses/>.
    17   */
    18  
    19  package neovm
    20  
    21  import (
    22  	"github.com/ontio/ontology/vm/neovm/interfaces"
    23  	"github.com/ontio/ontology/vm/neovm/types"
    24  )
    25  
    26  func (self *ValueStack) PushBool(val bool) error {
    27  	return self.Push(types.VmValueFromBool(val))
    28  }
    29  
    30  func (self *ValueStack) PopAsBool() (bool, error) {
    31  	val, err := self.Pop()
    32  	if err != nil {
    33  		return false, err
    34  	}
    35  
    36  	return val.AsBool()
    37  }
    38  
    39  func (self *ValueStack) PushInt64(val int64) error {
    40  	return self.Push(types.VmValueFromInt64(val))
    41  }
    42  
    43  func (self *ValueStack) PushUint64(val uint64) error {
    44  	return self.Push(types.VmValueFromUint64(val))
    45  }
    46  func (self *ValueStack) PushUint32(val uint32) error {
    47  	return self.Push(types.VmValueFromUint64(uint64(val)))
    48  }
    49  
    50  func (self *ValueStack) PopAsInt64() (int64, error) {
    51  	val, err := self.Pop()
    52  	if err != nil {
    53  		return 0, err
    54  	}
    55  	return val.AsInt64()
    56  }
    57  
    58  func (self *ValueStack) PopAsIntValue() (types.IntValue, error) {
    59  	val, err := self.Pop()
    60  	if err != nil {
    61  		return types.IntValue{}, err
    62  	}
    63  	return val.AsIntValue()
    64  }
    65  
    66  func (self *ValueStack) PushBytes(val []byte) error {
    67  	v, err := types.VmValueFromBytes(val)
    68  	if err != nil {
    69  		return err
    70  	}
    71  	return self.Push(v)
    72  }
    73  
    74  func (self *ValueStack) PopAsBytes() ([]byte, error) {
    75  	val, err := self.Pop()
    76  	if err != nil {
    77  		return nil, err
    78  	}
    79  	return val.AsBytes()
    80  }
    81  
    82  func (self *ValueStack) PopAsArray() (*types.ArrayValue, error) {
    83  	val, err := self.Pop()
    84  	if err != nil {
    85  		return nil, err
    86  	}
    87  	return val.AsArrayValue()
    88  }
    89  
    90  func (self *ValueStack) PopAsMap() (*types.MapValue, error) {
    91  	val, err := self.Pop()
    92  	if err != nil {
    93  		return nil, err
    94  	}
    95  	return val.AsMapValue()
    96  }
    97  
    98  func (self *ValueStack) PopAsStruct() (*types.StructValue, error) {
    99  	val, err := self.Pop()
   100  	if err != nil {
   101  		return nil, err
   102  	}
   103  	return val.AsStructValue()
   104  }
   105  
   106  func (self *ValueStack) PushAsInteropValue(val interfaces.Interop) error {
   107  	return self.Push(types.VmValueFromInteropValue(types.NewInteropValue(val)))
   108  }
   109  
   110  func (self *ValueStack) PopAsInteropValue() (types.InteropValue, error) {
   111  	val, err := self.Pop()
   112  	if err != nil {
   113  		return types.InteropValue{}, err
   114  	}
   115  	return val.AsInteropValue()
   116  }
   117  
   118  func (self *ValueStack) PopPairAsBytes() (left, right []byte, err error) {
   119  	right, err = self.PopAsBytes()
   120  	if err != nil {
   121  		return
   122  	}
   123  	left, err = self.PopAsBytes()
   124  	return
   125  }
   126  
   127  func (self *ValueStack) PopPairAsBool() (left, right bool, err error) {
   128  	right, err = self.PopAsBool()
   129  	if err != nil {
   130  		return
   131  	}
   132  	left, err = self.PopAsBool()
   133  	return
   134  }
   135  
   136  func (self *ValueStack) PopPairAsInt64() (left, right int64, err error) {
   137  	right, err = self.PopAsInt64()
   138  	if err != nil {
   139  		return
   140  	}
   141  	left, err = self.PopAsInt64()
   142  	return
   143  }
   144  
   145  func (self *ValueStack) PopPairAsIntVal() (left, right types.IntValue, err error) {
   146  	right, err = self.PopAsIntValue()
   147  	if err != nil {
   148  		return
   149  	}
   150  	left, err = self.PopAsIntValue()
   151  	return
   152  }
   153  
   154  func (self *ValueStack) PopTripleAsBytes() (left, middle, right []byte, err error) {
   155  	right, err = self.PopAsBytes()
   156  	if err != nil {
   157  		return
   158  	}
   159  	middle, err = self.PopAsBytes()
   160  	if err != nil {
   161  		return
   162  	}
   163  	left, err = self.PopAsBytes()
   164  	return
   165  }
   166  
   167  func (self *ValueStack) PopTripleAsBool() (left, middle, right bool, err error) {
   168  	right, err = self.PopAsBool()
   169  	if err != nil {
   170  		return
   171  	}
   172  	middle, err = self.PopAsBool()
   173  	if err != nil {
   174  		return
   175  	}
   176  	left, err = self.PopAsBool()
   177  	return
   178  }
   179  
   180  func (self *ValueStack) PopTripleAsIntVal() (left, middle, right types.IntValue, err error) {
   181  	right, err = self.PopAsIntValue()
   182  	if err != nil {
   183  		return
   184  	}
   185  	middle, err = self.PopAsIntValue()
   186  	if err != nil {
   187  		return
   188  	}
   189  	left, err = self.PopAsIntValue()
   190  	return
   191  }
   192  
   193  func (self *ValueStack) PeekAsBytes(index int64) ([]byte, error) {
   194  	val, err := self.Peek(index)
   195  	if err != nil {
   196  		return nil, err
   197  	}
   198  	bs, err := val.AsBytes()
   199  	if err != nil {
   200  		return nil, err
   201  	}
   202  	return bs, nil
   203  }