github.com/goplus/gossa@v0.3.25/opcvt.go (about)

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