github.com/goplus/igop@v0.25.0/opcvt.go (about)

     1  /*
     2   * Copyright (c) 2022 The GoPlus Authors (goplus.org). All rights reserved.
     3   *
     4   * Licensed under the Apache License, Version 2.0 (the "License");
     5   * you may not use this file except in compliance with the License.
     6   * You may obtain a copy of the License at
     7   *
     8   *     http://www.apache.org/licenses/LICENSE-2.0
     9   *
    10   * Unless required by applicable law or agreed to in writing, software
    11   * distributed under the License is distributed on an "AS IS" BASIS,
    12   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    13   * See the License for the specific language governing permissions and
    14   * limitations under the License.
    15   */
    16  
    17  package igop
    18  
    19  import (
    20  	"reflect"
    21  
    22  	"github.com/visualfc/xtype"
    23  )
    24  
    25  func cvtInt(ir, ix register, xkind reflect.Kind, xtyp reflect.Type, typ reflect.Type) func(fr *frame) {
    26  	type T = int
    27  	t := xtype.TypeOfType(typ)
    28  	isBasic := typ.PkgPath() == ""
    29  	if xtyp.PkgPath() == "" {
    30  		return func(fr *frame) {
    31  			var v T
    32  			switch xkind {
    33  			case reflect.Int:
    34  				v = T(fr.reg(ix).(int))
    35  			case reflect.Int8:
    36  				v = T(fr.reg(ix).(int8))
    37  			case reflect.Int16:
    38  				v = T(fr.reg(ix).(int16))
    39  			case reflect.Int32:
    40  				v = T(fr.reg(ix).(int32))
    41  			case reflect.Int64:
    42  				v = T(fr.reg(ix).(int64))
    43  			case reflect.Uint:
    44  				v = T(fr.reg(ix).(uint))
    45  			case reflect.Uint8:
    46  				v = T(fr.reg(ix).(uint8))
    47  			case reflect.Uint16:
    48  				v = T(fr.reg(ix).(uint16))
    49  			case reflect.Uint32:
    50  				v = T(fr.reg(ix).(uint32))
    51  			case reflect.Uint64:
    52  				v = T(fr.reg(ix).(uint64))
    53  			case reflect.Uintptr:
    54  				v = T(fr.reg(ix).(uintptr))
    55  			case reflect.Float32:
    56  				v = T(fr.reg(ix).(float32))
    57  			case reflect.Float64:
    58  				v = T(fr.reg(ix).(float64))
    59  			}
    60  			if isBasic {
    61  				fr.setReg(ir, v)
    62  			} else {
    63  				fr.setReg(ir, xtype.Make(t, v))
    64  			}
    65  		}
    66  	} else {
    67  		return func(fr *frame) {
    68  			var v T
    69  			switch xkind {
    70  			case reflect.Int:
    71  				v = T(fr.int(ix))
    72  			case reflect.Int8:
    73  				v = T(fr.int8(ix))
    74  			case reflect.Int16:
    75  				v = T(fr.int16(ix))
    76  			case reflect.Int32:
    77  				v = T(fr.int32(ix))
    78  			case reflect.Int64:
    79  				v = T(fr.int64(ix))
    80  			case reflect.Uint:
    81  				v = T(fr.uint(ix))
    82  			case reflect.Uint8:
    83  				v = T(fr.uint8(ix))
    84  			case reflect.Uint16:
    85  				v = T(fr.uint16(ix))
    86  			case reflect.Uint32:
    87  				v = T(fr.uint32(ix))
    88  			case reflect.Uint64:
    89  				v = T(fr.uint64(ix))
    90  			case reflect.Uintptr:
    91  				v = T(fr.uintptr(ix))
    92  			case reflect.Float32:
    93  				v = T(fr.float32(ix))
    94  			case reflect.Float64:
    95  				v = T(fr.float64(ix))
    96  			}
    97  			if isBasic {
    98  				fr.setReg(ir, v)
    99  			} else {
   100  				fr.setReg(ir, xtype.Make(t, v))
   101  			}
   102  		}
   103  	}
   104  }
   105  func cvtInt8(ir, ix register, xkind reflect.Kind, xtyp reflect.Type, typ reflect.Type) func(fr *frame) {
   106  	type T = int8
   107  	t := xtype.TypeOfType(typ)
   108  	isBasic := typ.PkgPath() == ""
   109  	if xtyp.PkgPath() == "" {
   110  		return func(fr *frame) {
   111  			var v T
   112  			switch xkind {
   113  			case reflect.Int:
   114  				v = T(fr.reg(ix).(int))
   115  			case reflect.Int8:
   116  				v = T(fr.reg(ix).(int8))
   117  			case reflect.Int16:
   118  				v = T(fr.reg(ix).(int16))
   119  			case reflect.Int32:
   120  				v = T(fr.reg(ix).(int32))
   121  			case reflect.Int64:
   122  				v = T(fr.reg(ix).(int64))
   123  			case reflect.Uint:
   124  				v = T(fr.reg(ix).(uint))
   125  			case reflect.Uint8:
   126  				v = T(fr.reg(ix).(uint8))
   127  			case reflect.Uint16:
   128  				v = T(fr.reg(ix).(uint16))
   129  			case reflect.Uint32:
   130  				v = T(fr.reg(ix).(uint32))
   131  			case reflect.Uint64:
   132  				v = T(fr.reg(ix).(uint64))
   133  			case reflect.Uintptr:
   134  				v = T(fr.reg(ix).(uintptr))
   135  			case reflect.Float32:
   136  				v = T(fr.reg(ix).(float32))
   137  			case reflect.Float64:
   138  				v = T(fr.reg(ix).(float64))
   139  			}
   140  			if isBasic {
   141  				fr.setReg(ir, v)
   142  			} else {
   143  				fr.setReg(ir, xtype.Make(t, v))
   144  			}
   145  		}
   146  	} else {
   147  		return func(fr *frame) {
   148  			var v T
   149  			switch xkind {
   150  			case reflect.Int:
   151  				v = T(fr.int(ix))
   152  			case reflect.Int8:
   153  				v = T(fr.int8(ix))
   154  			case reflect.Int16:
   155  				v = T(fr.int16(ix))
   156  			case reflect.Int32:
   157  				v = T(fr.int32(ix))
   158  			case reflect.Int64:
   159  				v = T(fr.int64(ix))
   160  			case reflect.Uint:
   161  				v = T(fr.uint(ix))
   162  			case reflect.Uint8:
   163  				v = T(fr.uint8(ix))
   164  			case reflect.Uint16:
   165  				v = T(fr.uint16(ix))
   166  			case reflect.Uint32:
   167  				v = T(fr.uint32(ix))
   168  			case reflect.Uint64:
   169  				v = T(fr.uint64(ix))
   170  			case reflect.Uintptr:
   171  				v = T(fr.uintptr(ix))
   172  			case reflect.Float32:
   173  				v = T(fr.float32(ix))
   174  			case reflect.Float64:
   175  				v = T(fr.float64(ix))
   176  			}
   177  			if isBasic {
   178  				fr.setReg(ir, v)
   179  			} else {
   180  				fr.setReg(ir, xtype.Make(t, v))
   181  			}
   182  		}
   183  	}
   184  }
   185  func cvtInt16(ir, ix register, xkind reflect.Kind, xtyp reflect.Type, typ reflect.Type) func(fr *frame) {
   186  	type T = int16
   187  	t := xtype.TypeOfType(typ)
   188  	isBasic := typ.PkgPath() == ""
   189  	if xtyp.PkgPath() == "" {
   190  		return func(fr *frame) {
   191  			var v T
   192  			switch xkind {
   193  			case reflect.Int:
   194  				v = T(fr.reg(ix).(int))
   195  			case reflect.Int8:
   196  				v = T(fr.reg(ix).(int8))
   197  			case reflect.Int16:
   198  				v = T(fr.reg(ix).(int16))
   199  			case reflect.Int32:
   200  				v = T(fr.reg(ix).(int32))
   201  			case reflect.Int64:
   202  				v = T(fr.reg(ix).(int64))
   203  			case reflect.Uint:
   204  				v = T(fr.reg(ix).(uint))
   205  			case reflect.Uint8:
   206  				v = T(fr.reg(ix).(uint8))
   207  			case reflect.Uint16:
   208  				v = T(fr.reg(ix).(uint16))
   209  			case reflect.Uint32:
   210  				v = T(fr.reg(ix).(uint32))
   211  			case reflect.Uint64:
   212  				v = T(fr.reg(ix).(uint64))
   213  			case reflect.Uintptr:
   214  				v = T(fr.reg(ix).(uintptr))
   215  			case reflect.Float32:
   216  				v = T(fr.reg(ix).(float32))
   217  			case reflect.Float64:
   218  				v = T(fr.reg(ix).(float64))
   219  			}
   220  			if isBasic {
   221  				fr.setReg(ir, v)
   222  			} else {
   223  				fr.setReg(ir, xtype.Make(t, v))
   224  			}
   225  		}
   226  	} else {
   227  		return func(fr *frame) {
   228  			var v T
   229  			switch xkind {
   230  			case reflect.Int:
   231  				v = T(fr.int(ix))
   232  			case reflect.Int8:
   233  				v = T(fr.int8(ix))
   234  			case reflect.Int16:
   235  				v = T(fr.int16(ix))
   236  			case reflect.Int32:
   237  				v = T(fr.int32(ix))
   238  			case reflect.Int64:
   239  				v = T(fr.int64(ix))
   240  			case reflect.Uint:
   241  				v = T(fr.uint(ix))
   242  			case reflect.Uint8:
   243  				v = T(fr.uint8(ix))
   244  			case reflect.Uint16:
   245  				v = T(fr.uint16(ix))
   246  			case reflect.Uint32:
   247  				v = T(fr.uint32(ix))
   248  			case reflect.Uint64:
   249  				v = T(fr.uint64(ix))
   250  			case reflect.Uintptr:
   251  				v = T(fr.uintptr(ix))
   252  			case reflect.Float32:
   253  				v = T(fr.float32(ix))
   254  			case reflect.Float64:
   255  				v = T(fr.float64(ix))
   256  			}
   257  			if isBasic {
   258  				fr.setReg(ir, v)
   259  			} else {
   260  				fr.setReg(ir, xtype.Make(t, v))
   261  			}
   262  		}
   263  	}
   264  }
   265  func cvtInt32(ir, ix register, xkind reflect.Kind, xtyp reflect.Type, typ reflect.Type) func(fr *frame) {
   266  	type T = int32
   267  	t := xtype.TypeOfType(typ)
   268  	isBasic := typ.PkgPath() == ""
   269  	if xtyp.PkgPath() == "" {
   270  		return func(fr *frame) {
   271  			var v T
   272  			switch xkind {
   273  			case reflect.Int:
   274  				v = T(fr.reg(ix).(int))
   275  			case reflect.Int8:
   276  				v = T(fr.reg(ix).(int8))
   277  			case reflect.Int16:
   278  				v = T(fr.reg(ix).(int16))
   279  			case reflect.Int32:
   280  				v = T(fr.reg(ix).(int32))
   281  			case reflect.Int64:
   282  				v = T(fr.reg(ix).(int64))
   283  			case reflect.Uint:
   284  				v = T(fr.reg(ix).(uint))
   285  			case reflect.Uint8:
   286  				v = T(fr.reg(ix).(uint8))
   287  			case reflect.Uint16:
   288  				v = T(fr.reg(ix).(uint16))
   289  			case reflect.Uint32:
   290  				v = T(fr.reg(ix).(uint32))
   291  			case reflect.Uint64:
   292  				v = T(fr.reg(ix).(uint64))
   293  			case reflect.Uintptr:
   294  				v = T(fr.reg(ix).(uintptr))
   295  			case reflect.Float32:
   296  				v = T(fr.reg(ix).(float32))
   297  			case reflect.Float64:
   298  				v = T(fr.reg(ix).(float64))
   299  			}
   300  			if isBasic {
   301  				fr.setReg(ir, v)
   302  			} else {
   303  				fr.setReg(ir, xtype.Make(t, v))
   304  			}
   305  		}
   306  	} else {
   307  		return func(fr *frame) {
   308  			var v T
   309  			switch xkind {
   310  			case reflect.Int:
   311  				v = T(fr.int(ix))
   312  			case reflect.Int8:
   313  				v = T(fr.int8(ix))
   314  			case reflect.Int16:
   315  				v = T(fr.int16(ix))
   316  			case reflect.Int32:
   317  				v = T(fr.int32(ix))
   318  			case reflect.Int64:
   319  				v = T(fr.int64(ix))
   320  			case reflect.Uint:
   321  				v = T(fr.uint(ix))
   322  			case reflect.Uint8:
   323  				v = T(fr.uint8(ix))
   324  			case reflect.Uint16:
   325  				v = T(fr.uint16(ix))
   326  			case reflect.Uint32:
   327  				v = T(fr.uint32(ix))
   328  			case reflect.Uint64:
   329  				v = T(fr.uint64(ix))
   330  			case reflect.Uintptr:
   331  				v = T(fr.uintptr(ix))
   332  			case reflect.Float32:
   333  				v = T(fr.float32(ix))
   334  			case reflect.Float64:
   335  				v = T(fr.float64(ix))
   336  			}
   337  			if isBasic {
   338  				fr.setReg(ir, v)
   339  			} else {
   340  				fr.setReg(ir, xtype.Make(t, v))
   341  			}
   342  		}
   343  	}
   344  }
   345  func cvtInt64(ir, ix register, xkind reflect.Kind, xtyp reflect.Type, typ reflect.Type) func(fr *frame) {
   346  	type T = int64
   347  	t := xtype.TypeOfType(typ)
   348  	isBasic := typ.PkgPath() == ""
   349  	if xtyp.PkgPath() == "" {
   350  		return func(fr *frame) {
   351  			var v T
   352  			switch xkind {
   353  			case reflect.Int:
   354  				v = T(fr.reg(ix).(int))
   355  			case reflect.Int8:
   356  				v = T(fr.reg(ix).(int8))
   357  			case reflect.Int16:
   358  				v = T(fr.reg(ix).(int16))
   359  			case reflect.Int32:
   360  				v = T(fr.reg(ix).(int32))
   361  			case reflect.Int64:
   362  				v = T(fr.reg(ix).(int64))
   363  			case reflect.Uint:
   364  				v = T(fr.reg(ix).(uint))
   365  			case reflect.Uint8:
   366  				v = T(fr.reg(ix).(uint8))
   367  			case reflect.Uint16:
   368  				v = T(fr.reg(ix).(uint16))
   369  			case reflect.Uint32:
   370  				v = T(fr.reg(ix).(uint32))
   371  			case reflect.Uint64:
   372  				v = T(fr.reg(ix).(uint64))
   373  			case reflect.Uintptr:
   374  				v = T(fr.reg(ix).(uintptr))
   375  			case reflect.Float32:
   376  				v = T(fr.reg(ix).(float32))
   377  			case reflect.Float64:
   378  				v = T(fr.reg(ix).(float64))
   379  			}
   380  			if isBasic {
   381  				fr.setReg(ir, v)
   382  			} else {
   383  				fr.setReg(ir, xtype.Make(t, v))
   384  			}
   385  		}
   386  	} else {
   387  		return func(fr *frame) {
   388  			var v T
   389  			switch xkind {
   390  			case reflect.Int:
   391  				v = T(fr.int(ix))
   392  			case reflect.Int8:
   393  				v = T(fr.int8(ix))
   394  			case reflect.Int16:
   395  				v = T(fr.int16(ix))
   396  			case reflect.Int32:
   397  				v = T(fr.int32(ix))
   398  			case reflect.Int64:
   399  				v = T(fr.int64(ix))
   400  			case reflect.Uint:
   401  				v = T(fr.uint(ix))
   402  			case reflect.Uint8:
   403  				v = T(fr.uint8(ix))
   404  			case reflect.Uint16:
   405  				v = T(fr.uint16(ix))
   406  			case reflect.Uint32:
   407  				v = T(fr.uint32(ix))
   408  			case reflect.Uint64:
   409  				v = T(fr.uint64(ix))
   410  			case reflect.Uintptr:
   411  				v = T(fr.uintptr(ix))
   412  			case reflect.Float32:
   413  				v = T(fr.float32(ix))
   414  			case reflect.Float64:
   415  				v = T(fr.float64(ix))
   416  			}
   417  			if isBasic {
   418  				fr.setReg(ir, v)
   419  			} else {
   420  				fr.setReg(ir, xtype.Make(t, v))
   421  			}
   422  		}
   423  	}
   424  }
   425  func cvtUint(ir, ix register, xkind reflect.Kind, xtyp reflect.Type, typ reflect.Type) func(fr *frame) {
   426  	type T = uint
   427  	t := xtype.TypeOfType(typ)
   428  	isBasic := typ.PkgPath() == ""
   429  	if xtyp.PkgPath() == "" {
   430  		return func(fr *frame) {
   431  			var v T
   432  			switch xkind {
   433  			case reflect.Int:
   434  				v = T(fr.reg(ix).(int))
   435  			case reflect.Int8:
   436  				v = T(fr.reg(ix).(int8))
   437  			case reflect.Int16:
   438  				v = T(fr.reg(ix).(int16))
   439  			case reflect.Int32:
   440  				v = T(fr.reg(ix).(int32))
   441  			case reflect.Int64:
   442  				v = T(fr.reg(ix).(int64))
   443  			case reflect.Uint:
   444  				v = T(fr.reg(ix).(uint))
   445  			case reflect.Uint8:
   446  				v = T(fr.reg(ix).(uint8))
   447  			case reflect.Uint16:
   448  				v = T(fr.reg(ix).(uint16))
   449  			case reflect.Uint32:
   450  				v = T(fr.reg(ix).(uint32))
   451  			case reflect.Uint64:
   452  				v = T(fr.reg(ix).(uint64))
   453  			case reflect.Uintptr:
   454  				v = T(fr.reg(ix).(uintptr))
   455  			case reflect.Float32:
   456  				v = T(fr.reg(ix).(float32))
   457  			case reflect.Float64:
   458  				v = T(fr.reg(ix).(float64))
   459  			}
   460  			if isBasic {
   461  				fr.setReg(ir, v)
   462  			} else {
   463  				fr.setReg(ir, xtype.Make(t, v))
   464  			}
   465  		}
   466  	} else {
   467  		return func(fr *frame) {
   468  			var v T
   469  			switch xkind {
   470  			case reflect.Int:
   471  				v = T(fr.int(ix))
   472  			case reflect.Int8:
   473  				v = T(fr.int8(ix))
   474  			case reflect.Int16:
   475  				v = T(fr.int16(ix))
   476  			case reflect.Int32:
   477  				v = T(fr.int32(ix))
   478  			case reflect.Int64:
   479  				v = T(fr.int64(ix))
   480  			case reflect.Uint:
   481  				v = T(fr.uint(ix))
   482  			case reflect.Uint8:
   483  				v = T(fr.uint8(ix))
   484  			case reflect.Uint16:
   485  				v = T(fr.uint16(ix))
   486  			case reflect.Uint32:
   487  				v = T(fr.uint32(ix))
   488  			case reflect.Uint64:
   489  				v = T(fr.uint64(ix))
   490  			case reflect.Uintptr:
   491  				v = T(fr.uintptr(ix))
   492  			case reflect.Float32:
   493  				v = T(fr.float32(ix))
   494  			case reflect.Float64:
   495  				v = T(fr.float64(ix))
   496  			}
   497  			if isBasic {
   498  				fr.setReg(ir, v)
   499  			} else {
   500  				fr.setReg(ir, xtype.Make(t, v))
   501  			}
   502  		}
   503  	}
   504  }
   505  func cvtUint8(ir, ix register, xkind reflect.Kind, xtyp reflect.Type, typ reflect.Type) func(fr *frame) {
   506  	type T = uint8
   507  	t := xtype.TypeOfType(typ)
   508  	isBasic := typ.PkgPath() == ""
   509  	if xtyp.PkgPath() == "" {
   510  		return func(fr *frame) {
   511  			var v T
   512  			switch xkind {
   513  			case reflect.Int:
   514  				v = T(fr.reg(ix).(int))
   515  			case reflect.Int8:
   516  				v = T(fr.reg(ix).(int8))
   517  			case reflect.Int16:
   518  				v = T(fr.reg(ix).(int16))
   519  			case reflect.Int32:
   520  				v = T(fr.reg(ix).(int32))
   521  			case reflect.Int64:
   522  				v = T(fr.reg(ix).(int64))
   523  			case reflect.Uint:
   524  				v = T(fr.reg(ix).(uint))
   525  			case reflect.Uint8:
   526  				v = T(fr.reg(ix).(uint8))
   527  			case reflect.Uint16:
   528  				v = T(fr.reg(ix).(uint16))
   529  			case reflect.Uint32:
   530  				v = T(fr.reg(ix).(uint32))
   531  			case reflect.Uint64:
   532  				v = T(fr.reg(ix).(uint64))
   533  			case reflect.Uintptr:
   534  				v = T(fr.reg(ix).(uintptr))
   535  			case reflect.Float32:
   536  				v = T(fr.reg(ix).(float32))
   537  			case reflect.Float64:
   538  				v = T(fr.reg(ix).(float64))
   539  			}
   540  			if isBasic {
   541  				fr.setReg(ir, v)
   542  			} else {
   543  				fr.setReg(ir, xtype.Make(t, v))
   544  			}
   545  		}
   546  	} else {
   547  		return func(fr *frame) {
   548  			var v T
   549  			switch xkind {
   550  			case reflect.Int:
   551  				v = T(fr.int(ix))
   552  			case reflect.Int8:
   553  				v = T(fr.int8(ix))
   554  			case reflect.Int16:
   555  				v = T(fr.int16(ix))
   556  			case reflect.Int32:
   557  				v = T(fr.int32(ix))
   558  			case reflect.Int64:
   559  				v = T(fr.int64(ix))
   560  			case reflect.Uint:
   561  				v = T(fr.uint(ix))
   562  			case reflect.Uint8:
   563  				v = T(fr.uint8(ix))
   564  			case reflect.Uint16:
   565  				v = T(fr.uint16(ix))
   566  			case reflect.Uint32:
   567  				v = T(fr.uint32(ix))
   568  			case reflect.Uint64:
   569  				v = T(fr.uint64(ix))
   570  			case reflect.Uintptr:
   571  				v = T(fr.uintptr(ix))
   572  			case reflect.Float32:
   573  				v = T(fr.float32(ix))
   574  			case reflect.Float64:
   575  				v = T(fr.float64(ix))
   576  			}
   577  			if isBasic {
   578  				fr.setReg(ir, v)
   579  			} else {
   580  				fr.setReg(ir, xtype.Make(t, v))
   581  			}
   582  		}
   583  	}
   584  }
   585  func cvtUint16(ir, ix register, xkind reflect.Kind, xtyp reflect.Type, typ reflect.Type) func(fr *frame) {
   586  	type T = uint16
   587  	t := xtype.TypeOfType(typ)
   588  	isBasic := typ.PkgPath() == ""
   589  	if xtyp.PkgPath() == "" {
   590  		return func(fr *frame) {
   591  			var v T
   592  			switch xkind {
   593  			case reflect.Int:
   594  				v = T(fr.reg(ix).(int))
   595  			case reflect.Int8:
   596  				v = T(fr.reg(ix).(int8))
   597  			case reflect.Int16:
   598  				v = T(fr.reg(ix).(int16))
   599  			case reflect.Int32:
   600  				v = T(fr.reg(ix).(int32))
   601  			case reflect.Int64:
   602  				v = T(fr.reg(ix).(int64))
   603  			case reflect.Uint:
   604  				v = T(fr.reg(ix).(uint))
   605  			case reflect.Uint8:
   606  				v = T(fr.reg(ix).(uint8))
   607  			case reflect.Uint16:
   608  				v = T(fr.reg(ix).(uint16))
   609  			case reflect.Uint32:
   610  				v = T(fr.reg(ix).(uint32))
   611  			case reflect.Uint64:
   612  				v = T(fr.reg(ix).(uint64))
   613  			case reflect.Uintptr:
   614  				v = T(fr.reg(ix).(uintptr))
   615  			case reflect.Float32:
   616  				v = T(fr.reg(ix).(float32))
   617  			case reflect.Float64:
   618  				v = T(fr.reg(ix).(float64))
   619  			}
   620  			if isBasic {
   621  				fr.setReg(ir, v)
   622  			} else {
   623  				fr.setReg(ir, xtype.Make(t, v))
   624  			}
   625  		}
   626  	} else {
   627  		return func(fr *frame) {
   628  			var v T
   629  			switch xkind {
   630  			case reflect.Int:
   631  				v = T(fr.int(ix))
   632  			case reflect.Int8:
   633  				v = T(fr.int8(ix))
   634  			case reflect.Int16:
   635  				v = T(fr.int16(ix))
   636  			case reflect.Int32:
   637  				v = T(fr.int32(ix))
   638  			case reflect.Int64:
   639  				v = T(fr.int64(ix))
   640  			case reflect.Uint:
   641  				v = T(fr.uint(ix))
   642  			case reflect.Uint8:
   643  				v = T(fr.uint8(ix))
   644  			case reflect.Uint16:
   645  				v = T(fr.uint16(ix))
   646  			case reflect.Uint32:
   647  				v = T(fr.uint32(ix))
   648  			case reflect.Uint64:
   649  				v = T(fr.uint64(ix))
   650  			case reflect.Uintptr:
   651  				v = T(fr.uintptr(ix))
   652  			case reflect.Float32:
   653  				v = T(fr.float32(ix))
   654  			case reflect.Float64:
   655  				v = T(fr.float64(ix))
   656  			}
   657  			if isBasic {
   658  				fr.setReg(ir, v)
   659  			} else {
   660  				fr.setReg(ir, xtype.Make(t, v))
   661  			}
   662  		}
   663  	}
   664  }
   665  func cvtUint32(ir, ix register, xkind reflect.Kind, xtyp reflect.Type, typ reflect.Type) func(fr *frame) {
   666  	type T = uint32
   667  	t := xtype.TypeOfType(typ)
   668  	isBasic := typ.PkgPath() == ""
   669  	if xtyp.PkgPath() == "" {
   670  		return func(fr *frame) {
   671  			var v T
   672  			switch xkind {
   673  			case reflect.Int:
   674  				v = T(fr.reg(ix).(int))
   675  			case reflect.Int8:
   676  				v = T(fr.reg(ix).(int8))
   677  			case reflect.Int16:
   678  				v = T(fr.reg(ix).(int16))
   679  			case reflect.Int32:
   680  				v = T(fr.reg(ix).(int32))
   681  			case reflect.Int64:
   682  				v = T(fr.reg(ix).(int64))
   683  			case reflect.Uint:
   684  				v = T(fr.reg(ix).(uint))
   685  			case reflect.Uint8:
   686  				v = T(fr.reg(ix).(uint8))
   687  			case reflect.Uint16:
   688  				v = T(fr.reg(ix).(uint16))
   689  			case reflect.Uint32:
   690  				v = T(fr.reg(ix).(uint32))
   691  			case reflect.Uint64:
   692  				v = T(fr.reg(ix).(uint64))
   693  			case reflect.Uintptr:
   694  				v = T(fr.reg(ix).(uintptr))
   695  			case reflect.Float32:
   696  				v = T(fr.reg(ix).(float32))
   697  			case reflect.Float64:
   698  				v = T(fr.reg(ix).(float64))
   699  			}
   700  			if isBasic {
   701  				fr.setReg(ir, v)
   702  			} else {
   703  				fr.setReg(ir, xtype.Make(t, v))
   704  			}
   705  		}
   706  	} else {
   707  		return func(fr *frame) {
   708  			var v T
   709  			switch xkind {
   710  			case reflect.Int:
   711  				v = T(fr.int(ix))
   712  			case reflect.Int8:
   713  				v = T(fr.int8(ix))
   714  			case reflect.Int16:
   715  				v = T(fr.int16(ix))
   716  			case reflect.Int32:
   717  				v = T(fr.int32(ix))
   718  			case reflect.Int64:
   719  				v = T(fr.int64(ix))
   720  			case reflect.Uint:
   721  				v = T(fr.uint(ix))
   722  			case reflect.Uint8:
   723  				v = T(fr.uint8(ix))
   724  			case reflect.Uint16:
   725  				v = T(fr.uint16(ix))
   726  			case reflect.Uint32:
   727  				v = T(fr.uint32(ix))
   728  			case reflect.Uint64:
   729  				v = T(fr.uint64(ix))
   730  			case reflect.Uintptr:
   731  				v = T(fr.uintptr(ix))
   732  			case reflect.Float32:
   733  				v = T(fr.float32(ix))
   734  			case reflect.Float64:
   735  				v = T(fr.float64(ix))
   736  			}
   737  			if isBasic {
   738  				fr.setReg(ir, v)
   739  			} else {
   740  				fr.setReg(ir, xtype.Make(t, v))
   741  			}
   742  		}
   743  	}
   744  }
   745  func cvtUint64(ir, ix register, xkind reflect.Kind, xtyp reflect.Type, typ reflect.Type) func(fr *frame) {
   746  	type T = uint64
   747  	t := xtype.TypeOfType(typ)
   748  	isBasic := typ.PkgPath() == ""
   749  	if xtyp.PkgPath() == "" {
   750  		return func(fr *frame) {
   751  			var v T
   752  			switch xkind {
   753  			case reflect.Int:
   754  				v = T(fr.reg(ix).(int))
   755  			case reflect.Int8:
   756  				v = T(fr.reg(ix).(int8))
   757  			case reflect.Int16:
   758  				v = T(fr.reg(ix).(int16))
   759  			case reflect.Int32:
   760  				v = T(fr.reg(ix).(int32))
   761  			case reflect.Int64:
   762  				v = T(fr.reg(ix).(int64))
   763  			case reflect.Uint:
   764  				v = T(fr.reg(ix).(uint))
   765  			case reflect.Uint8:
   766  				v = T(fr.reg(ix).(uint8))
   767  			case reflect.Uint16:
   768  				v = T(fr.reg(ix).(uint16))
   769  			case reflect.Uint32:
   770  				v = T(fr.reg(ix).(uint32))
   771  			case reflect.Uint64:
   772  				v = T(fr.reg(ix).(uint64))
   773  			case reflect.Uintptr:
   774  				v = T(fr.reg(ix).(uintptr))
   775  			case reflect.Float32:
   776  				v = T(fr.reg(ix).(float32))
   777  			case reflect.Float64:
   778  				v = T(fr.reg(ix).(float64))
   779  			}
   780  			if isBasic {
   781  				fr.setReg(ir, v)
   782  			} else {
   783  				fr.setReg(ir, xtype.Make(t, v))
   784  			}
   785  		}
   786  	} else {
   787  		return func(fr *frame) {
   788  			var v T
   789  			switch xkind {
   790  			case reflect.Int:
   791  				v = T(fr.int(ix))
   792  			case reflect.Int8:
   793  				v = T(fr.int8(ix))
   794  			case reflect.Int16:
   795  				v = T(fr.int16(ix))
   796  			case reflect.Int32:
   797  				v = T(fr.int32(ix))
   798  			case reflect.Int64:
   799  				v = T(fr.int64(ix))
   800  			case reflect.Uint:
   801  				v = T(fr.uint(ix))
   802  			case reflect.Uint8:
   803  				v = T(fr.uint8(ix))
   804  			case reflect.Uint16:
   805  				v = T(fr.uint16(ix))
   806  			case reflect.Uint32:
   807  				v = T(fr.uint32(ix))
   808  			case reflect.Uint64:
   809  				v = T(fr.uint64(ix))
   810  			case reflect.Uintptr:
   811  				v = T(fr.uintptr(ix))
   812  			case reflect.Float32:
   813  				v = T(fr.float32(ix))
   814  			case reflect.Float64:
   815  				v = T(fr.float64(ix))
   816  			}
   817  			if isBasic {
   818  				fr.setReg(ir, v)
   819  			} else {
   820  				fr.setReg(ir, xtype.Make(t, v))
   821  			}
   822  		}
   823  	}
   824  }
   825  func cvtUintptr(ir, ix register, xkind reflect.Kind, xtyp reflect.Type, typ reflect.Type) func(fr *frame) {
   826  	type T = uintptr
   827  	t := xtype.TypeOfType(typ)
   828  	isBasic := typ.PkgPath() == ""
   829  	if xtyp.PkgPath() == "" {
   830  		return func(fr *frame) {
   831  			var v T
   832  			switch xkind {
   833  			case reflect.Int:
   834  				v = T(fr.reg(ix).(int))
   835  			case reflect.Int8:
   836  				v = T(fr.reg(ix).(int8))
   837  			case reflect.Int16:
   838  				v = T(fr.reg(ix).(int16))
   839  			case reflect.Int32:
   840  				v = T(fr.reg(ix).(int32))
   841  			case reflect.Int64:
   842  				v = T(fr.reg(ix).(int64))
   843  			case reflect.Uint:
   844  				v = T(fr.reg(ix).(uint))
   845  			case reflect.Uint8:
   846  				v = T(fr.reg(ix).(uint8))
   847  			case reflect.Uint16:
   848  				v = T(fr.reg(ix).(uint16))
   849  			case reflect.Uint32:
   850  				v = T(fr.reg(ix).(uint32))
   851  			case reflect.Uint64:
   852  				v = T(fr.reg(ix).(uint64))
   853  			case reflect.Uintptr:
   854  				v = T(fr.reg(ix).(uintptr))
   855  			case reflect.Float32:
   856  				v = T(fr.reg(ix).(float32))
   857  			case reflect.Float64:
   858  				v = T(fr.reg(ix).(float64))
   859  			}
   860  			if isBasic {
   861  				fr.setReg(ir, v)
   862  			} else {
   863  				fr.setReg(ir, xtype.Make(t, v))
   864  			}
   865  		}
   866  	} else {
   867  		return func(fr *frame) {
   868  			var v T
   869  			switch xkind {
   870  			case reflect.Int:
   871  				v = T(fr.int(ix))
   872  			case reflect.Int8:
   873  				v = T(fr.int8(ix))
   874  			case reflect.Int16:
   875  				v = T(fr.int16(ix))
   876  			case reflect.Int32:
   877  				v = T(fr.int32(ix))
   878  			case reflect.Int64:
   879  				v = T(fr.int64(ix))
   880  			case reflect.Uint:
   881  				v = T(fr.uint(ix))
   882  			case reflect.Uint8:
   883  				v = T(fr.uint8(ix))
   884  			case reflect.Uint16:
   885  				v = T(fr.uint16(ix))
   886  			case reflect.Uint32:
   887  				v = T(fr.uint32(ix))
   888  			case reflect.Uint64:
   889  				v = T(fr.uint64(ix))
   890  			case reflect.Uintptr:
   891  				v = T(fr.uintptr(ix))
   892  			case reflect.Float32:
   893  				v = T(fr.float32(ix))
   894  			case reflect.Float64:
   895  				v = T(fr.float64(ix))
   896  			}
   897  			if isBasic {
   898  				fr.setReg(ir, v)
   899  			} else {
   900  				fr.setReg(ir, xtype.Make(t, v))
   901  			}
   902  		}
   903  	}
   904  }
   905  func cvtFloat32(ir, ix register, xkind reflect.Kind, xtyp reflect.Type, typ reflect.Type) func(fr *frame) {
   906  	type T = float32
   907  	t := xtype.TypeOfType(typ)
   908  	isBasic := typ.PkgPath() == ""
   909  	if xtyp.PkgPath() == "" {
   910  		return func(fr *frame) {
   911  			var v T
   912  			switch xkind {
   913  			case reflect.Int:
   914  				v = T(fr.reg(ix).(int))
   915  			case reflect.Int8:
   916  				v = T(fr.reg(ix).(int8))
   917  			case reflect.Int16:
   918  				v = T(fr.reg(ix).(int16))
   919  			case reflect.Int32:
   920  				v = T(fr.reg(ix).(int32))
   921  			case reflect.Int64:
   922  				v = T(fr.reg(ix).(int64))
   923  			case reflect.Uint:
   924  				v = T(fr.reg(ix).(uint))
   925  			case reflect.Uint8:
   926  				v = T(fr.reg(ix).(uint8))
   927  			case reflect.Uint16:
   928  				v = T(fr.reg(ix).(uint16))
   929  			case reflect.Uint32:
   930  				v = T(fr.reg(ix).(uint32))
   931  			case reflect.Uint64:
   932  				v = T(fr.reg(ix).(uint64))
   933  			case reflect.Uintptr:
   934  				v = T(fr.reg(ix).(uintptr))
   935  			case reflect.Float32:
   936  				v = T(fr.reg(ix).(float32))
   937  			case reflect.Float64:
   938  				v = T(fr.reg(ix).(float64))
   939  			}
   940  			if isBasic {
   941  				fr.setReg(ir, v)
   942  			} else {
   943  				fr.setReg(ir, xtype.Make(t, v))
   944  			}
   945  		}
   946  	} else {
   947  		return func(fr *frame) {
   948  			var v T
   949  			switch xkind {
   950  			case reflect.Int:
   951  				v = T(fr.int(ix))
   952  			case reflect.Int8:
   953  				v = T(fr.int8(ix))
   954  			case reflect.Int16:
   955  				v = T(fr.int16(ix))
   956  			case reflect.Int32:
   957  				v = T(fr.int32(ix))
   958  			case reflect.Int64:
   959  				v = T(fr.int64(ix))
   960  			case reflect.Uint:
   961  				v = T(fr.uint(ix))
   962  			case reflect.Uint8:
   963  				v = T(fr.uint8(ix))
   964  			case reflect.Uint16:
   965  				v = T(fr.uint16(ix))
   966  			case reflect.Uint32:
   967  				v = T(fr.uint32(ix))
   968  			case reflect.Uint64:
   969  				v = T(fr.uint64(ix))
   970  			case reflect.Uintptr:
   971  				v = T(fr.uintptr(ix))
   972  			case reflect.Float32:
   973  				v = T(fr.float32(ix))
   974  			case reflect.Float64:
   975  				v = T(fr.float64(ix))
   976  			}
   977  			if isBasic {
   978  				fr.setReg(ir, v)
   979  			} else {
   980  				fr.setReg(ir, xtype.Make(t, v))
   981  			}
   982  		}
   983  	}
   984  }
   985  func cvtFloat64(ir, ix register, xkind reflect.Kind, xtyp reflect.Type, typ reflect.Type) func(fr *frame) {
   986  	type T = float64
   987  	t := xtype.TypeOfType(typ)
   988  	isBasic := typ.PkgPath() == ""
   989  	if xtyp.PkgPath() == "" {
   990  		return func(fr *frame) {
   991  			var v T
   992  			switch xkind {
   993  			case reflect.Int:
   994  				v = T(fr.reg(ix).(int))
   995  			case reflect.Int8:
   996  				v = T(fr.reg(ix).(int8))
   997  			case reflect.Int16:
   998  				v = T(fr.reg(ix).(int16))
   999  			case reflect.Int32:
  1000  				v = T(fr.reg(ix).(int32))
  1001  			case reflect.Int64:
  1002  				v = T(fr.reg(ix).(int64))
  1003  			case reflect.Uint:
  1004  				v = T(fr.reg(ix).(uint))
  1005  			case reflect.Uint8:
  1006  				v = T(fr.reg(ix).(uint8))
  1007  			case reflect.Uint16:
  1008  				v = T(fr.reg(ix).(uint16))
  1009  			case reflect.Uint32:
  1010  				v = T(fr.reg(ix).(uint32))
  1011  			case reflect.Uint64:
  1012  				v = T(fr.reg(ix).(uint64))
  1013  			case reflect.Uintptr:
  1014  				v = T(fr.reg(ix).(uintptr))
  1015  			case reflect.Float32:
  1016  				v = T(fr.reg(ix).(float32))
  1017  			case reflect.Float64:
  1018  				v = T(fr.reg(ix).(float64))
  1019  			}
  1020  			if isBasic {
  1021  				fr.setReg(ir, v)
  1022  			} else {
  1023  				fr.setReg(ir, xtype.Make(t, v))
  1024  			}
  1025  		}
  1026  	} else {
  1027  		return func(fr *frame) {
  1028  			var v T
  1029  			switch xkind {
  1030  			case reflect.Int:
  1031  				v = T(fr.int(ix))
  1032  			case reflect.Int8:
  1033  				v = T(fr.int8(ix))
  1034  			case reflect.Int16:
  1035  				v = T(fr.int16(ix))
  1036  			case reflect.Int32:
  1037  				v = T(fr.int32(ix))
  1038  			case reflect.Int64:
  1039  				v = T(fr.int64(ix))
  1040  			case reflect.Uint:
  1041  				v = T(fr.uint(ix))
  1042  			case reflect.Uint8:
  1043  				v = T(fr.uint8(ix))
  1044  			case reflect.Uint16:
  1045  				v = T(fr.uint16(ix))
  1046  			case reflect.Uint32:
  1047  				v = T(fr.uint32(ix))
  1048  			case reflect.Uint64:
  1049  				v = T(fr.uint64(ix))
  1050  			case reflect.Uintptr:
  1051  				v = T(fr.uintptr(ix))
  1052  			case reflect.Float32:
  1053  				v = T(fr.float32(ix))
  1054  			case reflect.Float64:
  1055  				v = T(fr.float64(ix))
  1056  			}
  1057  			if isBasic {
  1058  				fr.setReg(ir, v)
  1059  			} else {
  1060  				fr.setReg(ir, xtype.Make(t, v))
  1061  			}
  1062  		}
  1063  	}
  1064  }
  1065  func cvtComplex64(ir, ix register, xkind reflect.Kind, xtyp reflect.Type, typ reflect.Type) func(fr *frame) {
  1066  	type T = complex64
  1067  	t := xtype.TypeOfType(typ)
  1068  	isBasic := typ.PkgPath() == ""
  1069  	if xtyp.PkgPath() == "" {
  1070  		return func(fr *frame) {
  1071  			var v T
  1072  			switch xkind {
  1073  			case reflect.Complex64:
  1074  				v = T(fr.reg(ix).(complex64))
  1075  			case reflect.Complex128:
  1076  				v = T(fr.reg(ix).(complex128))
  1077  			}
  1078  			if isBasic {
  1079  				fr.setReg(ir, v)
  1080  			} else {
  1081  				fr.setReg(ir, xtype.Make(t, v))
  1082  			}
  1083  		}
  1084  	} else {
  1085  		return func(fr *frame) {
  1086  			var v T
  1087  			switch xkind {
  1088  			case reflect.Complex64:
  1089  				v = T(fr.complex64(ix))
  1090  			case reflect.Complex128:
  1091  				v = T(fr.complex128(ix))
  1092  			}
  1093  			if isBasic {
  1094  				fr.setReg(ir, v)
  1095  			} else {
  1096  				fr.setReg(ir, xtype.Make(t, v))
  1097  			}
  1098  		}
  1099  	}
  1100  }
  1101  func cvtComplex128(ir, ix register, xkind reflect.Kind, xtyp reflect.Type, typ reflect.Type) func(fr *frame) {
  1102  	type T = complex128
  1103  	t := xtype.TypeOfType(typ)
  1104  	isBasic := typ.PkgPath() == ""
  1105  	if xtyp.PkgPath() == "" {
  1106  		return func(fr *frame) {
  1107  			var v T
  1108  			switch xkind {
  1109  			case reflect.Complex64:
  1110  				v = T(fr.reg(ix).(complex64))
  1111  			case reflect.Complex128:
  1112  				v = T(fr.reg(ix).(complex128))
  1113  			}
  1114  			if isBasic {
  1115  				fr.setReg(ir, v)
  1116  			} else {
  1117  				fr.setReg(ir, xtype.Make(t, v))
  1118  			}
  1119  		}
  1120  	} else {
  1121  		return func(fr *frame) {
  1122  			var v T
  1123  			switch xkind {
  1124  			case reflect.Complex64:
  1125  				v = T(fr.complex64(ix))
  1126  			case reflect.Complex128:
  1127  				v = T(fr.complex128(ix))
  1128  			}
  1129  			if isBasic {
  1130  				fr.setReg(ir, v)
  1131  			} else {
  1132  				fr.setReg(ir, xtype.Make(t, v))
  1133  			}
  1134  		}
  1135  	}
  1136  }