github.com/mmatczuk/gohan@v0.0.0-20170206152520-30e45d9bdb69/extension/gohanscript/autogen/lib_gohan.go (about)

     1  package autogen
     2  
     3  // AUTO GENERATED CODE DO NOT MODIFY MANUALLY
     4  import (
     5  	"github.com/cloudwan/gohan/db"
     6  	"github.com/cloudwan/gohan/db/transaction"
     7  	"github.com/cloudwan/gohan/extension/gohanscript"
     8  	"github.com/cloudwan/gohan/extension/gohanscript/lib"
     9  )
    10  
    11  func init() {
    12  
    13  	gohanscript.RegisterStmtParser("gohan_schema",
    14  		func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) {
    15  			return func(context *gohanscript.Context) (interface{}, error) {
    16  
    17  				var schemaID string
    18  				ischemaID := stmt.Arg("schema_id", context)
    19  				if ischemaID != nil {
    20  					schemaID = ischemaID.(string)
    21  				}
    22  
    23  				result1,
    24  					err :=
    25  					lib.GohanSchema(
    26  						schemaID)
    27  
    28  				return result1, err
    29  
    30  			}, nil
    31  		})
    32  	gohanscript.RegisterMiniGoFunc("GohanSchema",
    33  		func(vm *gohanscript.VM, args []interface{}) []interface{} {
    34  
    35  			schemaID, _ := args[0].(string)
    36  
    37  			result1,
    38  				err :=
    39  				lib.GohanSchema(
    40  					schemaID)
    41  			return []interface{}{
    42  				result1,
    43  				err}
    44  
    45  		})
    46  
    47  	gohanscript.RegisterStmtParser("gohan_schemas",
    48  		func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) {
    49  			return func(context *gohanscript.Context) (interface{}, error) {
    50  
    51  				result1 :=
    52  					lib.GohanSchemas()
    53  
    54  				return result1, nil
    55  
    56  			}, nil
    57  		})
    58  	gohanscript.RegisterMiniGoFunc("GohanSchemas",
    59  		func(vm *gohanscript.VM, args []interface{}) []interface{} {
    60  
    61  			result1 :=
    62  				lib.GohanSchemas()
    63  			return []interface{}{
    64  				result1}
    65  
    66  		})
    67  
    68  	gohanscript.RegisterStmtParser("gohan_policies",
    69  		func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) {
    70  			return func(context *gohanscript.Context) (interface{}, error) {
    71  
    72  				result1 :=
    73  					lib.GohanPolicies()
    74  
    75  				return result1, nil
    76  
    77  			}, nil
    78  		})
    79  	gohanscript.RegisterMiniGoFunc("GohanPolicies",
    80  		func(vm *gohanscript.VM, args []interface{}) []interface{} {
    81  
    82  			result1 :=
    83  				lib.GohanPolicies()
    84  			return []interface{}{
    85  				result1}
    86  
    87  		})
    88  
    89  	gohanscript.RegisterStmtParser("read_config",
    90  		func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) {
    91  			return func(context *gohanscript.Context) (interface{}, error) {
    92  
    93  				var path string
    94  				ipath := stmt.Arg("path", context)
    95  				if ipath != nil {
    96  					path = ipath.(string)
    97  				}
    98  
    99  				err :=
   100  					lib.ReadConfig(
   101  						path)
   102  
   103  				return nil, err
   104  
   105  			}, nil
   106  		})
   107  	gohanscript.RegisterMiniGoFunc("ReadConfig",
   108  		func(vm *gohanscript.VM, args []interface{}) []interface{} {
   109  
   110  			path, _ := args[0].(string)
   111  
   112  			err :=
   113  				lib.ReadConfig(
   114  					path)
   115  			return []interface{}{
   116  				err}
   117  
   118  		})
   119  
   120  	gohanscript.RegisterStmtParser("get_config",
   121  		func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) {
   122  			return func(context *gohanscript.Context) (interface{}, error) {
   123  
   124  				var key string
   125  				ikey := stmt.Arg("key", context)
   126  				if ikey != nil {
   127  					key = ikey.(string)
   128  				}
   129  				var defaultValue interface{}
   130  				idefaultValue := stmt.Arg("default_value", context)
   131  				if idefaultValue != nil {
   132  					defaultValue = idefaultValue.(interface{})
   133  				}
   134  
   135  				result1 :=
   136  					lib.GetConfig(
   137  						key, defaultValue)
   138  
   139  				return result1, nil
   140  
   141  			}, nil
   142  		})
   143  	gohanscript.RegisterMiniGoFunc("GetConfig",
   144  		func(vm *gohanscript.VM, args []interface{}) []interface{} {
   145  
   146  			key, _ := args[0].(string)
   147  			defaultValue, _ := args[0].(interface{})
   148  
   149  			result1 :=
   150  				lib.GetConfig(
   151  					key, defaultValue)
   152  			return []interface{}{
   153  				result1}
   154  
   155  		})
   156  
   157  	gohanscript.RegisterStmtParser("gohan_load_schema",
   158  		func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) {
   159  			return func(context *gohanscript.Context) (interface{}, error) {
   160  
   161  				var src string
   162  				isrc := stmt.Arg("src", context)
   163  				if isrc != nil {
   164  					src = isrc.(string)
   165  				}
   166  
   167  				result1,
   168  					err :=
   169  					lib.GohanLoadSchema(
   170  						src)
   171  
   172  				return result1, err
   173  
   174  			}, nil
   175  		})
   176  	gohanscript.RegisterMiniGoFunc("GohanLoadSchema",
   177  		func(vm *gohanscript.VM, args []interface{}) []interface{} {
   178  
   179  			src, _ := args[0].(string)
   180  
   181  			result1,
   182  				err :=
   183  				lib.GohanLoadSchema(
   184  					src)
   185  			return []interface{}{
   186  				result1,
   187  				err}
   188  
   189  		})
   190  
   191  	gohanscript.RegisterStmtParser("connect_db",
   192  		func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) {
   193  			return func(context *gohanscript.Context) (interface{}, error) {
   194  
   195  				var dbType string
   196  				idbType := stmt.Arg("db_type", context)
   197  				if idbType != nil {
   198  					dbType = idbType.(string)
   199  				}
   200  				var connection string
   201  				iconnection := stmt.Arg("connection", context)
   202  				if iconnection != nil {
   203  					connection = iconnection.(string)
   204  				}
   205  				var maxOpenConn int
   206  				imaxOpenConn := stmt.Arg("max_open_conn", context)
   207  				if imaxOpenConn != nil {
   208  					maxOpenConn = imaxOpenConn.(int)
   209  				}
   210  
   211  				result1,
   212  					err :=
   213  					lib.ConnectDB(
   214  						dbType, connection, maxOpenConn)
   215  
   216  				return result1, err
   217  
   218  			}, nil
   219  		})
   220  	gohanscript.RegisterMiniGoFunc("ConnectDB",
   221  		func(vm *gohanscript.VM, args []interface{}) []interface{} {
   222  
   223  			dbType, _ := args[0].(string)
   224  			connection, _ := args[0].(string)
   225  			maxOpenConn, _ := args[0].(int)
   226  
   227  			result1,
   228  				err :=
   229  				lib.ConnectDB(
   230  					dbType, connection, maxOpenConn)
   231  			return []interface{}{
   232  				result1,
   233  				err}
   234  
   235  		})
   236  
   237  	gohanscript.RegisterStmtParser("init_db",
   238  		func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) {
   239  			return func(context *gohanscript.Context) (interface{}, error) {
   240  
   241  				var dbType string
   242  				idbType := stmt.Arg("db_type", context)
   243  				if idbType != nil {
   244  					dbType = idbType.(string)
   245  				}
   246  				var connection string
   247  				iconnection := stmt.Arg("connection", context)
   248  				if iconnection != nil {
   249  					connection = iconnection.(string)
   250  				}
   251  				var dropOnCreate bool
   252  				idropOnCreate := stmt.Arg("drop_on_create", context)
   253  				if idropOnCreate != nil {
   254  					dropOnCreate = idropOnCreate.(bool)
   255  				}
   256  				var cascade bool
   257  				icascade := stmt.Arg("cascade", context)
   258  				if icascade != nil {
   259  					cascade = icascade.(bool)
   260  				}
   261  
   262  				err :=
   263  					lib.InitDB(
   264  						dbType, connection, dropOnCreate, cascade)
   265  
   266  				return nil, err
   267  
   268  			}, nil
   269  		})
   270  	gohanscript.RegisterMiniGoFunc("InitDB",
   271  		func(vm *gohanscript.VM, args []interface{}) []interface{} {
   272  
   273  			dbType, _ := args[0].(string)
   274  			connection, _ := args[0].(string)
   275  			dropOnCreate, _ := args[0].(bool)
   276  			cascade, _ := args[0].(bool)
   277  
   278  			err :=
   279  				lib.InitDB(
   280  					dbType, connection, dropOnCreate, cascade)
   281  			return []interface{}{
   282  				err}
   283  
   284  		})
   285  
   286  	gohanscript.RegisterStmtParser("db_begin",
   287  		func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) {
   288  			return func(context *gohanscript.Context) (interface{}, error) {
   289  
   290  				var connection db.DB
   291  				iconnection := stmt.Arg("connection", context)
   292  				if iconnection != nil {
   293  					connection = iconnection.(db.DB)
   294  				}
   295  
   296  				result1,
   297  					err :=
   298  					lib.DBBegin(
   299  						connection)
   300  
   301  				return result1, err
   302  
   303  			}, nil
   304  		})
   305  	gohanscript.RegisterMiniGoFunc("DBBegin",
   306  		func(vm *gohanscript.VM, args []interface{}) []interface{} {
   307  
   308  			connection, _ := args[0].(db.DB)
   309  
   310  			result1,
   311  				err :=
   312  				lib.DBBegin(
   313  					connection)
   314  			return []interface{}{
   315  				result1,
   316  				err}
   317  
   318  		})
   319  
   320  	gohanscript.RegisterStmtParser("db_commit",
   321  		func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) {
   322  			return func(context *gohanscript.Context) (interface{}, error) {
   323  
   324  				var tx transaction.Transaction
   325  				itx := stmt.Arg("tx", context)
   326  				if itx != nil {
   327  					tx = itx.(transaction.Transaction)
   328  				}
   329  
   330  				err :=
   331  					lib.DBCommit(
   332  						tx)
   333  
   334  				return nil, err
   335  
   336  			}, nil
   337  		})
   338  	gohanscript.RegisterMiniGoFunc("DBCommit",
   339  		func(vm *gohanscript.VM, args []interface{}) []interface{} {
   340  
   341  			tx, _ := args[0].(transaction.Transaction)
   342  
   343  			err :=
   344  				lib.DBCommit(
   345  					tx)
   346  			return []interface{}{
   347  				err}
   348  
   349  		})
   350  
   351  	gohanscript.RegisterStmtParser("db_close",
   352  		func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) {
   353  			return func(context *gohanscript.Context) (interface{}, error) {
   354  
   355  				var tx transaction.Transaction
   356  				itx := stmt.Arg("tx", context)
   357  				if itx != nil {
   358  					tx = itx.(transaction.Transaction)
   359  				}
   360  
   361  				err :=
   362  					lib.DBClose(
   363  						tx)
   364  
   365  				return nil, err
   366  
   367  			}, nil
   368  		})
   369  	gohanscript.RegisterMiniGoFunc("DBClose",
   370  		func(vm *gohanscript.VM, args []interface{}) []interface{} {
   371  
   372  			tx, _ := args[0].(transaction.Transaction)
   373  
   374  			err :=
   375  				lib.DBClose(
   376  					tx)
   377  			return []interface{}{
   378  				err}
   379  
   380  		})
   381  
   382  	gohanscript.RegisterStmtParser("db_get",
   383  		func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) {
   384  			return func(context *gohanscript.Context) (interface{}, error) {
   385  
   386  				var tx transaction.Transaction
   387  				itx := stmt.Arg("tx", context)
   388  				if itx != nil {
   389  					tx = itx.(transaction.Transaction)
   390  				}
   391  				var schemaID string
   392  				ischemaID := stmt.Arg("schema_id", context)
   393  				if ischemaID != nil {
   394  					schemaID = ischemaID.(string)
   395  				}
   396  				var id string
   397  				iid := stmt.Arg("id", context)
   398  				if iid != nil {
   399  					id = iid.(string)
   400  				}
   401  				var tenantID string
   402  				itenantID := stmt.Arg("tenant_id", context)
   403  				if itenantID != nil {
   404  					tenantID = itenantID.(string)
   405  				}
   406  
   407  				result1,
   408  					err :=
   409  					lib.DBGet(
   410  						tx, schemaID, id, tenantID)
   411  
   412  				return result1, err
   413  
   414  			}, nil
   415  		})
   416  	gohanscript.RegisterMiniGoFunc("DBGet",
   417  		func(vm *gohanscript.VM, args []interface{}) []interface{} {
   418  
   419  			tx, _ := args[0].(transaction.Transaction)
   420  			schemaID, _ := args[0].(string)
   421  			id, _ := args[0].(string)
   422  			tenantID, _ := args[0].(string)
   423  
   424  			result1,
   425  				err :=
   426  				lib.DBGet(
   427  					tx, schemaID, id, tenantID)
   428  			return []interface{}{
   429  				result1,
   430  				err}
   431  
   432  		})
   433  
   434  	gohanscript.RegisterStmtParser("db_create",
   435  		func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) {
   436  			return func(context *gohanscript.Context) (interface{}, error) {
   437  
   438  				var tx transaction.Transaction
   439  				itx := stmt.Arg("tx", context)
   440  				if itx != nil {
   441  					tx = itx.(transaction.Transaction)
   442  				}
   443  				var schemaID string
   444  				ischemaID := stmt.Arg("schema_id", context)
   445  				if ischemaID != nil {
   446  					schemaID = ischemaID.(string)
   447  				}
   448  				var data map[string]interface{}
   449  				idata := stmt.Arg("data", context)
   450  				if idata != nil {
   451  					data = idata.(map[string]interface{})
   452  				}
   453  
   454  				err :=
   455  					lib.DBCreate(
   456  						tx, schemaID, data)
   457  
   458  				return nil, err
   459  
   460  			}, nil
   461  		})
   462  	gohanscript.RegisterMiniGoFunc("DBCreate",
   463  		func(vm *gohanscript.VM, args []interface{}) []interface{} {
   464  
   465  			tx, _ := args[0].(transaction.Transaction)
   466  			schemaID, _ := args[0].(string)
   467  			data, _ := args[0].(map[string]interface{})
   468  
   469  			err :=
   470  				lib.DBCreate(
   471  					tx, schemaID, data)
   472  			return []interface{}{
   473  				err}
   474  
   475  		})
   476  
   477  	gohanscript.RegisterStmtParser("db_list",
   478  		func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) {
   479  			return func(context *gohanscript.Context) (interface{}, error) {
   480  
   481  				var tx transaction.Transaction
   482  				itx := stmt.Arg("tx", context)
   483  				if itx != nil {
   484  					tx = itx.(transaction.Transaction)
   485  				}
   486  				var schemaID string
   487  				ischemaID := stmt.Arg("schema_id", context)
   488  				if ischemaID != nil {
   489  					schemaID = ischemaID.(string)
   490  				}
   491  				var filter map[string]interface{}
   492  				ifilter := stmt.Arg("filter", context)
   493  				if ifilter != nil {
   494  					filter = ifilter.(map[string]interface{})
   495  				}
   496  
   497  				result1,
   498  					err :=
   499  					lib.DBList(
   500  						tx, schemaID, filter)
   501  
   502  				return result1, err
   503  
   504  			}, nil
   505  		})
   506  	gohanscript.RegisterMiniGoFunc("DBList",
   507  		func(vm *gohanscript.VM, args []interface{}) []interface{} {
   508  
   509  			tx, _ := args[0].(transaction.Transaction)
   510  			schemaID, _ := args[0].(string)
   511  			filter, _ := args[0].(map[string]interface{})
   512  
   513  			result1,
   514  				err :=
   515  				lib.DBList(
   516  					tx, schemaID, filter)
   517  			return []interface{}{
   518  				result1,
   519  				err}
   520  
   521  		})
   522  
   523  	gohanscript.RegisterStmtParser("db_update",
   524  		func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) {
   525  			return func(context *gohanscript.Context) (interface{}, error) {
   526  
   527  				var tx transaction.Transaction
   528  				itx := stmt.Arg("tx", context)
   529  				if itx != nil {
   530  					tx = itx.(transaction.Transaction)
   531  				}
   532  				var schemaID string
   533  				ischemaID := stmt.Arg("schema_id", context)
   534  				if ischemaID != nil {
   535  					schemaID = ischemaID.(string)
   536  				}
   537  				var data map[string]interface{}
   538  				idata := stmt.Arg("data", context)
   539  				if idata != nil {
   540  					data = idata.(map[string]interface{})
   541  				}
   542  
   543  				err :=
   544  					lib.DBUpdate(
   545  						tx, schemaID, data)
   546  
   547  				return nil, err
   548  
   549  			}, nil
   550  		})
   551  	gohanscript.RegisterMiniGoFunc("DBUpdate",
   552  		func(vm *gohanscript.VM, args []interface{}) []interface{} {
   553  
   554  			tx, _ := args[0].(transaction.Transaction)
   555  			schemaID, _ := args[0].(string)
   556  			data, _ := args[0].(map[string]interface{})
   557  
   558  			err :=
   559  				lib.DBUpdate(
   560  					tx, schemaID, data)
   561  			return []interface{}{
   562  				err}
   563  
   564  		})
   565  
   566  	gohanscript.RegisterStmtParser("db_delete",
   567  		func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) {
   568  			return func(context *gohanscript.Context) (interface{}, error) {
   569  
   570  				var tx transaction.Transaction
   571  				itx := stmt.Arg("tx", context)
   572  				if itx != nil {
   573  					tx = itx.(transaction.Transaction)
   574  				}
   575  				var schemaID string
   576  				ischemaID := stmt.Arg("schema_id", context)
   577  				if ischemaID != nil {
   578  					schemaID = ischemaID.(string)
   579  				}
   580  				var id string
   581  				iid := stmt.Arg("id", context)
   582  				if iid != nil {
   583  					id = iid.(string)
   584  				}
   585  
   586  				err :=
   587  					lib.DBDelete(
   588  						tx, schemaID, id)
   589  
   590  				return nil, err
   591  
   592  			}, nil
   593  		})
   594  	gohanscript.RegisterMiniGoFunc("DBDelete",
   595  		func(vm *gohanscript.VM, args []interface{}) []interface{} {
   596  
   597  			tx, _ := args[0].(transaction.Transaction)
   598  			schemaID, _ := args[0].(string)
   599  			id, _ := args[0].(string)
   600  
   601  			err :=
   602  				lib.DBDelete(
   603  					tx, schemaID, id)
   604  			return []interface{}{
   605  				err}
   606  
   607  		})
   608  
   609  	gohanscript.RegisterStmtParser("db_query",
   610  		func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) {
   611  			return func(context *gohanscript.Context) (interface{}, error) {
   612  
   613  				var tx transaction.Transaction
   614  				itx := stmt.Arg("tx", context)
   615  				if itx != nil {
   616  					tx = itx.(transaction.Transaction)
   617  				}
   618  				var schemaID string
   619  				ischemaID := stmt.Arg("schema_id", context)
   620  				if ischemaID != nil {
   621  					schemaID = ischemaID.(string)
   622  				}
   623  				var sql string
   624  				isql := stmt.Arg("sql", context)
   625  				if isql != nil {
   626  					sql = isql.(string)
   627  				}
   628  				var arguments []interface{}
   629  				iarguments := stmt.Arg("arguments", context)
   630  				if iarguments != nil {
   631  					arguments = iarguments.([]interface{})
   632  				}
   633  
   634  				result1,
   635  					err :=
   636  					lib.DBQuery(
   637  						tx, schemaID, sql, arguments)
   638  
   639  				return result1, err
   640  
   641  			}, nil
   642  		})
   643  	gohanscript.RegisterMiniGoFunc("DBQuery",
   644  		func(vm *gohanscript.VM, args []interface{}) []interface{} {
   645  
   646  			tx, _ := args[0].(transaction.Transaction)
   647  			schemaID, _ := args[0].(string)
   648  			sql, _ := args[0].(string)
   649  			arguments, _ := args[0].([]interface{})
   650  
   651  			result1,
   652  				err :=
   653  				lib.DBQuery(
   654  					tx, schemaID, sql, arguments)
   655  			return []interface{}{
   656  				result1,
   657  				err}
   658  
   659  		})
   660  
   661  	gohanscript.RegisterStmtParser("db_exec",
   662  		func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) {
   663  			return func(context *gohanscript.Context) (interface{}, error) {
   664  
   665  				var tx transaction.Transaction
   666  				itx := stmt.Arg("tx", context)
   667  				if itx != nil {
   668  					tx = itx.(transaction.Transaction)
   669  				}
   670  				var sql string
   671  				isql := stmt.Arg("sql", context)
   672  				if isql != nil {
   673  					sql = isql.(string)
   674  				}
   675  				var arguments []interface{}
   676  				iarguments := stmt.Arg("arguments", context)
   677  				if iarguments != nil {
   678  					arguments = iarguments.([]interface{})
   679  				}
   680  
   681  				err :=
   682  					lib.DBExec(
   683  						tx, sql, arguments)
   684  
   685  				return nil, err
   686  
   687  			}, nil
   688  		})
   689  	gohanscript.RegisterMiniGoFunc("DBExec",
   690  		func(vm *gohanscript.VM, args []interface{}) []interface{} {
   691  
   692  			tx, _ := args[0].(transaction.Transaction)
   693  			sql, _ := args[0].(string)
   694  			arguments, _ := args[0].([]interface{})
   695  
   696  			err :=
   697  				lib.DBExec(
   698  					tx, sql, arguments)
   699  			return []interface{}{
   700  				err}
   701  
   702  		})
   703  
   704  	gohanscript.RegisterStmtParser("db_column",
   705  		func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) {
   706  			return func(context *gohanscript.Context) (interface{}, error) {
   707  
   708  				var schemaID string
   709  				ischemaID := stmt.Arg("schema_id", context)
   710  				if ischemaID != nil {
   711  					schemaID = ischemaID.(string)
   712  				}
   713  				var join bool
   714  				ijoin := stmt.Arg("join", context)
   715  				if ijoin != nil {
   716  					join = ijoin.(bool)
   717  				}
   718  
   719  				result1,
   720  					err :=
   721  					lib.DBColumn(
   722  						schemaID, join)
   723  
   724  				return result1, err
   725  
   726  			}, nil
   727  		})
   728  	gohanscript.RegisterMiniGoFunc("DBColumn",
   729  		func(vm *gohanscript.VM, args []interface{}) []interface{} {
   730  
   731  			schemaID, _ := args[0].(string)
   732  			join, _ := args[0].(bool)
   733  
   734  			result1,
   735  				err :=
   736  				lib.DBColumn(
   737  					schemaID, join)
   738  			return []interface{}{
   739  				result1,
   740  				err}
   741  
   742  		})
   743  
   744  	gohanscript.RegisterStmtParser("error",
   745  		func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) {
   746  			return func(context *gohanscript.Context) (interface{}, error) {
   747  
   748  				var code int
   749  				icode := stmt.Arg("code", context)
   750  				if icode != nil {
   751  					code = icode.(int)
   752  				}
   753  				var name string
   754  				iname := stmt.Arg("name", context)
   755  				if iname != nil {
   756  					name = iname.(string)
   757  				}
   758  				var message string
   759  				imessage := stmt.Arg("message", context)
   760  				if imessage != nil {
   761  					message = imessage.(string)
   762  				}
   763  
   764  				err :=
   765  					lib.Error(
   766  						code, name, message)
   767  
   768  				return nil, err
   769  
   770  			}, nil
   771  		})
   772  	gohanscript.RegisterMiniGoFunc("Error",
   773  		func(vm *gohanscript.VM, args []interface{}) []interface{} {
   774  
   775  			code, _ := args[0].(int)
   776  			name, _ := args[0].(string)
   777  			message, _ := args[1].(string)
   778  
   779  			err :=
   780  				lib.Error(
   781  					code, name, message)
   782  			return []interface{}{
   783  				err}
   784  
   785  		})
   786  
   787  }