diff --git a/Makefile b/Makefile index bb45466e..69ac8e04 100644 --- a/Makefile +++ b/Makefile @@ -12,6 +12,48 @@ endif build: go build -o ${OUTPUT_PATH} ./cmd/baton-sql +# DB2 support requires the native IBM CLI driver at build and run time (see docs/db2.md). +# Flags are scoped to this target only — do not export CGO_CFLAGS/CGO_LDFLAGS in your shell. +# -ldb2 is omitted on purpose: go_ibm_db's cgo directives already add it. +# +# The binary resolves libdb2 relative to itself first (./clidriver/lib next to the +# executable), then at the build-time DB2HOME, so one artifact works both untarred +# alongside a bundled driver (see package-db2) and on hosts with a system-wide install. +# On macOS, libdb2.dylib's install name is the bare filename, so the darwin steps rewrite +# the load command to @rpath and re-sign (ad-hoc). No LD_LIBRARY_PATH/DYLD_LIBRARY_PATH +# is needed at run time in either layout. +DB2HOME ?= /usr/local/clidriver + +ifeq ($(GOOS),darwin) +DB2_RPATH_FLAGS = -Wl,-rpath,@executable_path/clidriver/lib -Wl,-rpath,$(DB2HOME)/lib +else +DB2_RPATH_FLAGS = -Wl,-rpath,$$ORIGIN/clidriver/lib -Wl,-z,origin -Wl,-rpath,$(DB2HOME)/lib +endif + +.PHONY: build-db2 +build-db2: + CGO_CFLAGS='-I$(DB2HOME)/include' CGO_LDFLAGS='-L$(DB2HOME)/lib $(DB2_RPATH_FLAGS)' \ + go build -tags db2 -o ${OUTPUT_PATH} ./cmd/baton-sql +ifeq ($(GOOS),darwin) + install_name_tool -change libdb2.dylib @rpath/libdb2.dylib ${OUTPUT_PATH} + codesign -f -s - ${OUTPUT_PATH} +endif + +# Self-contained DB2 distribution: binary + clidriver (including its license/ directory, +# which the IBM redistribution terms require shipping) in one archive. Untar and run — +# no installation, no environment variables. +BUNDLE_NAME = baton-sql-db2-${GOOS}-${GOARCH} +BUNDLE_DIR = dist/${BUNDLE_NAME} + +.PHONY: package-db2 +package-db2: build-db2 + rm -rf ${BUNDLE_DIR} ${BUNDLE_DIR}.tar.gz + mkdir -p ${BUNDLE_DIR} + cp ${OUTPUT_PATH} ${BUNDLE_DIR}/ + cp -R $(DB2HOME) ${BUNDLE_DIR}/clidriver + tar -czf ${BUNDLE_DIR}.tar.gz -C dist ${BUNDLE_NAME} + @echo "Created ${BUNDLE_DIR}.tar.gz" + .PHONY: update-deps update-deps: go get -d -u ./... diff --git a/README.md b/README.md index ecfd3080..3b016088 100644 --- a/README.md +++ b/README.md @@ -25,6 +25,7 @@ - PostgreSQL - Vertica - Amazon Redshift +- IBM DB2 — opt-in: requires a binary built with the `db2` tag and IBM's native CLI driver; see [docs/db2.md](docs/db2.md) ## Configuration diff --git a/docs/db2.md b/docs/db2.md new file mode 100644 index 00000000..6922a829 --- /dev/null +++ b/docs/db2.md @@ -0,0 +1,181 @@ +# DB2 Support + +IBM DB2 support is **opt-in** and built with `make build-db2`. Unlike every other engine in +baton-sql (all pure Go), DB2 uses the cgo driver `github.com/ibmdb/go_ibm_db`, which links +against IBM's native ODBC/CLI driver ("clidriver"). No pure-Go DB2 driver exists — the native +dependency cannot be eliminated, so it is isolated behind the `db2` build tag instead. + +What this means in practice: + +- `make build` (and CI, releases, cross-compilation) needs **no** IBM software, no CGO flags, + and no environment variables. DB2 code is excluded from default builds. +- A default binary given a `db2://` DSN fails with a clear error: + `baton-sql: DB2 support not compiled into this binary; rebuild with -tags db2 (see docs/db2.md)`. +- `make build-db2` produces a DB2-capable binary. The CGO flags are scoped to that one make + target — **do not export `CGO_CFLAGS`/`CGO_LDFLAGS` in your shell profile**. Global CGO flags + leak into every cgo link on your machine and break unrelated Go builds. +- The built binary needs no `LD_LIBRARY_PATH`/`DYLD_LIBRARY_PATH` at run time: the Makefile + bakes the lookup into the binary. It resolves the clidriver **relative to itself first** + (`./clidriver` next to the executable), then falls back to the build-time `DB2HOME` path — + so `make package-db2` produces a self-contained archive customers untar and run anywhere. + +## Prerequisites + +- Go 1.24 or later and a C compiler (clang/gcc) +- IBM DB2 ODBC/CLI driver (clidriver) for your platform — free download, no license key + +## Step 1: Install the clidriver + +Download the archive for your platform from +`https://public.dhe.ibm.com/ibmdl/export/pub/software/data/db2/drivers/odbc_cli/`: + +| Platform | Archive | +|----------|---------| +| macOS ARM64 (Apple Silicon) | `macarm64_odbc_cli.tar.gz` | +| macOS x86_64 (Intel) | `macos64_odbc_cli.tar.gz` | +| Linux x86_64 | `linuxx64_odbc_cli.tar.gz` | +| Linux ARM64 | **Not available** — IBM does not ship a Linux ARM64 clidriver | +| Linux ppc64le | `linuxppc64le_odbc_cli.tar.gz` | + +```bash +curl -O https://public.dhe.ibm.com/ibmdl/export/pub/software/data/db2/drivers/odbc_cli/macarm64_odbc_cli.tar.gz +tar -xzf macarm64_odbc_cli.tar.gz +sudo mv clidriver /usr/local/ +rm macarm64_odbc_cli.tar.gz +``` + +Any location works; `/usr/local/clidriver` is the default the Makefile assumes. + +## Step 2: Build + +```bash +make build-db2 # clidriver at /usr/local/clidriver +DB2HOME=/opt/clidriver make build-db2 # clidriver elsewhere +``` + +That's it — no shell configuration. The target runs +`go build -tags db2` with `CGO_CFLAGS`/`CGO_LDFLAGS` set inline for that command only +(`-ldb2` is deliberately omitted; the driver's own cgo directives add it), then on macOS +rewrites the dylib load command with `install_name_tool` and re-signs the binary. + +```bash +# Verify — runs without any library-path environment variables: +./dist/darwin_arm64/baton-sql -h +``` + +## Distributing to customers (binary bundle) + +Most deployments run the bare binary, not Docker. `make package-db2` produces a single +self-contained archive: + +```bash +make package-db2 +# -> dist/baton-sql-db2--.tar.gz (~55 MB) +``` + +The archive holds the binary with the clidriver beside it (including the `license/` +directory IBM's redistribution terms require): + +``` +baton-sql-db2-linux-amd64/ +├── baton-sql +└── clidriver/ +``` + +The customer untars it anywhere and runs `./baton-sql` — no installation, no root, no +environment variables. The binary finds the driver via its baked-in relative path +(`$ORIGIN/clidriver/lib` on Linux, `@executable_path/clidriver/lib` on macOS); if a +system-wide clidriver exists at the build-time `DB2HOME` it serves as fallback. The two +directories must stay side by side — moving the binary out of the bundle alone breaks the +relative lookup (the fallback still applies if present). + +Platform notes: Linux bundles are glibc-only (no Alpine/musl) and x86_64 only — IBM ships +no Linux ARM64 clidriver. The clidriver needs `libxml2` from the OS (`apt-get install +libxml2` / `yum install libxml2`) — preinstalled on virtually every full server distro, +absent in minimal container images. A Linux bundle must be built on Linux (cgo — use the +Docker builder below or any amd64 Linux host). + +## DSN Format + +Standard URL form (recommended) — converted to DB2's native format automatically: + +``` +db2://username:password@hostname:port/database +db2://db2inst1:pass123@localhost:50000/TESTDB +``` + +Query parameters are forwarded as additional DB2 connection keywords +(e.g. `db2://user:pass@host:50000/DB?Security=SSL` adds `SECURITY=SSL`). Values containing +`;` are brace-quoted automatically; parameters that would override the URL-derived keywords +(`HOSTNAME`, `DATABASE`, `PORT`, `PROTOCOL`, `UID`, `PWD`) are rejected — use the native +form below for full control. + +DB2's native form is also accepted as-is: + +``` +HOSTNAME=localhost;PORT=50000;DATABASE=TESTDB;UID=db2inst1;PWD=pass123;PROTOCOL=TCPIP +``` + +## Troubleshooting + +**`'sqlcli1.h' file not found`** — clidriver missing or `DB2HOME` wrong. Check that +`$DB2HOME/include/sqlcli1.h` exists. If you see this from `make build` (not `build-db2`), +something reintroduced the driver into the default build — the `db2` tag gate is broken. + +**`found architecture 'x86_64', required architecture 'arm64'`** — wrong clidriver archive +for your CPU; see the table above. + +**`Library not loaded: libdb2.dylib` / `libdb2.so: cannot open shared object file`** — the +binary can't find the clidriver in either of its baked-in locations: `./clidriver/lib` next +to the executable, then the build-time `DB2HOME` path. Restore the bundle layout (binary and +`clidriver/` side by side), rebuild with `make build-db2`, or set +`LD_LIBRARY_PATH`/`DYLD_LIBRARY_PATH` to the clidriver `lib` dir as a stopgap. This also +happens when `go build -tags db2` is invoked directly, skipping the Makefile's +rpath/install_name steps. Note macOS SIP strips `DYLD_*` variables across protected +binaries — the baked paths are the reliable option. + +**`error while loading shared libraries: libxml2.so.2`** (Linux) — the clidriver depends on +the OS libxml2 package: `apt-get install libxml2` / `yum install libxml2`. + +**`go vet` / `golangci-lint` with `-tags db2` fails** — type-checking the tagged path needs +the clidriver headers too. Default-tag lint and vet need nothing. + +## Docker + +- The default release pipeline (goreleaser, `CGO_ENABLED=0`) is unaffected — DB2 does not + ride the standard release. Ship DB2 as the binary bundle above or as a separate Docker + image. +- Use a **glibc** base (Debian/Ubuntu/UBI). The clidriver does not support musl, so Alpine + is out. **linux/amd64 only** (no ARM64 clidriver). +- Bake the rpath at build time and copy the clidriver into the runtime image at the same + path — no `LD_LIBRARY_PATH` needed. + +```dockerfile +FROM golang:1.24-bookworm AS builder +RUN curl -sO https://public.dhe.ibm.com/ibmdl/export/pub/software/data/db2/drivers/odbc_cli/linuxx64_odbc_cli.tar.gz && \ + tar -xzf linuxx64_odbc_cli.tar.gz && mv clidriver /opt/clidriver +WORKDIR /src +COPY . . +RUN CGO_CFLAGS="-I/opt/clidriver/include" \ + CGO_LDFLAGS="-L/opt/clidriver/lib -Wl,-rpath,/opt/clidriver/lib" \ + go build -tags db2 -o /baton-sql ./cmd/baton-sql + +FROM debian:bookworm-slim +RUN apt-get update && apt-get install -y --no-install-recommends libxml2 && \ + rm -rf /var/lib/apt/lists/* +COPY --from=builder /opt/clidriver /opt/clidriver +COPY --from=builder /baton-sql /baton-sql +ENTRYPOINT ["/baton-sql"] +``` + +### Redistribution licensing + +Bundling the clidriver in a distributed image is expressly permitted by the IBM license's +"Redistributables" clause (IPLA + License Information document, shipped inside the tarball +at `clidriver/license/`), with conditions: distribute only the files enumerated in +`odbc_REDIST.txt`, keep the `license/` directory and copyright notices, and your end-user +terms must be at least as protective of IBM as IBM's own. Two caveats before shipping to +customers: the GSKit TLS libraries (`libgsk8*`) are not in the enumerated redistributables +list — get legal/IBM sign-off if TLS connections to DB2 are needed — and the Db2 Connect +license file (`db2consv_*.lic`, required for direct z/OS or IBM i connections) is **not** +redistributable; customers must supply their own. diff --git a/go.mod b/go.mod index 2d177723..9e23df00 100644 --- a/go.mod +++ b/go.mod @@ -10,6 +10,7 @@ require ( github.com/go-sql-driver/mysql v1.9.2 github.com/google/cel-go v0.28.1 github.com/grpc-ecosystem/go-grpc-middleware v1.4.0 + github.com/ibmdb/go_ibm_db v0.5.2 github.com/jackc/pgx/v5 v5.10.0 github.com/microsoft/go-mssqldb v1.8.0 github.com/quasilyte/go-ruleguard/dsl v0.3.23 @@ -88,6 +89,7 @@ require ( github.com/golang/snappy v0.0.5-0.20231225225746-43d5d4cd4e0e // indirect github.com/google/uuid v1.6.0 // indirect github.com/grpc-ecosystem/grpc-gateway/v2 v2.27.3 // indirect + github.com/ibmruntimes/go-recordio/v2 v2.0.0-20240416213906-ae0ad556db70 // indirect github.com/inconshreveable/mousetrap v1.1.0 // indirect github.com/jackc/pgpassfile v1.0.0 // indirect github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 // indirect diff --git a/go.sum b/go.sum index 8630799a..5cd35474 100644 --- a/go.sum +++ b/go.sum @@ -203,6 +203,10 @@ github.com/grpc-ecosystem/grpc-gateway/v2 v2.27.3 h1:NmZ1PKzSTQbuGHw9DGPFomqkkLW github.com/grpc-ecosystem/grpc-gateway/v2 v2.27.3/go.mod h1:zQrxl1YP88HQlA6i9c63DSVPFklWpGX4OWAc9bFuaH4= github.com/hashicorp/golang-lru/v2 v2.0.7 h1:a+bsQ5rvGLjzHuww6tVxozPZFVghXaHOwFs4luLUK2k= github.com/hashicorp/golang-lru/v2 v2.0.7/go.mod h1:QeFd9opnmA6QUJc5vARoKUSoFhyfM2/ZepoAG6RGpeM= +github.com/ibmdb/go_ibm_db v0.5.2 h1:g5bHeJdy4SXhw6c9PX1I3Tn4KrCbAzl2faX1BfTTR/8= +github.com/ibmdb/go_ibm_db v0.5.2/go.mod h1:BA12Alfe+h5BMGZGE+b0pqP4leILZkpoxe5qr/iMoHw= +github.com/ibmruntimes/go-recordio/v2 v2.0.0-20240416213906-ae0ad556db70 h1:muF5XqVkHnMdbMDXusPdKtuT8qWzefBgSuLH1JVHcC4= +github.com/ibmruntimes/go-recordio/v2 v2.0.0-20240416213906-ae0ad556db70/go.mod h1:NSpUK0x9IyEoM1EjTp2/S8ErxZfRHoA2DfwiYobFSkc= github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8= github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw= github.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsIM= diff --git a/pkg/bsql/helpers.go b/pkg/bsql/helpers.go index 7f004ffb..31c19258 100644 --- a/pkg/bsql/helpers.go +++ b/pkg/bsql/helpers.go @@ -128,6 +128,14 @@ func parseTimeWithEngine(value string, dbEngine database.DbEngine) (*time.Time, "2006-01-02 15:04:05", time.RFC3339, } + case database.DB2: + // DB2 common formats, including its native dash/dot TIMESTAMP string form + prioritizedFormats = []string{ + "2006-01-02 15:04:05.000000", + "2006-01-02-15.04.05.000000", + "2006-01-02 15:04:05", + time.RFC3339, + } default: // Try the generic time parser for unknown engines return parseTime(value) diff --git a/pkg/bsql/query.go b/pkg/bsql/query.go index c13a0c53..8affd2f5 100644 --- a/pkg/bsql/query.go +++ b/pkg/bsql/query.go @@ -85,6 +85,8 @@ func (s *SQLSyncer) getNextPlaceholder(qArgs []interface{}) string { return fmt.Sprintf(":%d", len(qArgs)) case database.Vertica: return "?" + case database.DB2: + return "?" default: return "?" } diff --git a/pkg/database/database.go b/pkg/database/database.go index 1c9c0748..a9b057dd 100644 --- a/pkg/database/database.go +++ b/pkg/database/database.go @@ -11,6 +11,7 @@ import ( "regexp" "strings" + "github.com/conductorone/baton-sql/pkg/database/db2" "github.com/conductorone/baton-sql/pkg/database/hdb" "github.com/conductorone/baton-sql/pkg/database/mysql" "github.com/conductorone/baton-sql/pkg/database/oracle" @@ -32,6 +33,7 @@ const ( Oracle HDB Vertica + DB2 ) // ConnectOptions represents the structured configuration used to build a DSN. @@ -425,6 +427,13 @@ func Connect(ctx context.Context, opts ConnectOptions) (*sql.DB, DbEngine, error } return db, Vertica, nil + case "db2": + db, err := db2.Connect(ctx, parsedDsn.String()) + if err != nil { + return nil, Unknown, err + } + return db, DB2, nil + default: return nil, Unknown, fmt.Errorf("unsupported database scheme: %s", parsedDsn.Scheme) } diff --git a/pkg/database/db2/db2.go b/pkg/database/db2/db2.go new file mode 100644 index 00000000..1b942c65 --- /dev/null +++ b/pkg/database/db2/db2.go @@ -0,0 +1,37 @@ +//go:build db2 + +package db2 + +import ( + "context" + "database/sql" + "time" + + _ "github.com/ibmdb/go_ibm_db" +) + +// Connect establishes a connection to DB2 database. +func Connect(ctx context.Context, dsn string) (*sql.DB, error) { + // Convert URL format to DB2 DSN format if needed + db2DSN, err := convertToDB2DSN(dsn) + if err != nil { + return nil, err + } + + db, err := sql.Open("go_ibm_db", db2DSN) + if err != nil { + return nil, err + } + + db.SetConnMaxLifetime(time.Minute * 5) + db.SetMaxOpenConns(25) + db.SetMaxIdleConns(25) + + // Test the connection + if err := db.PingContext(ctx); err != nil { + db.Close() + return nil, err + } + + return db, nil +} diff --git a/pkg/database/db2/db2_stub.go b/pkg/database/db2/db2_stub.go new file mode 100644 index 00000000..389b6b59 --- /dev/null +++ b/pkg/database/db2/db2_stub.go @@ -0,0 +1,16 @@ +//go:build !db2 + +package db2 + +import ( + "context" + "database/sql" + "errors" +) + +// Connect is a stub used when DB2 support is not compiled in. The go_ibm_db +// driver requires cgo and the IBM clidriver at build time, so it is only +// included when building with -tags db2. +func Connect(_ context.Context, _ string) (*sql.DB, error) { + return nil, errors.New("baton-sql: DB2 support not compiled into this binary; rebuild with -tags db2 (see docs/db2.md)") +} diff --git a/pkg/database/db2/dsn.go b/pkg/database/db2/dsn.go new file mode 100644 index 00000000..30d901d1 --- /dev/null +++ b/pkg/database/db2/dsn.go @@ -0,0 +1,125 @@ +package db2 + +import ( + "fmt" + "net/url" + "sort" + "strings" +) + +// Keywords derived from the URL itself; query parameters may not override them. +// Anyone needing full control over these can pass a native DB2 DSN instead. +var reservedDSNKeywords = map[string]bool{ + "HOSTNAME": true, + "DATABASE": true, + "PORT": true, + "PROTOCOL": true, + "UID": true, + "PWD": true, +} + +// quoteDB2Value returns v in a form safe to embed in DB2's semicolon-delimited +// keyword=value DSN format, brace-quoting per ODBC convention when needed. +// A literal '}' cannot be represented inside a braced value, so it is rejected. +func quoteDB2Value(v string) (string, error) { + if strings.Contains(v, "}") { + return "", fmt.Errorf("value must not contain '}'") + } + if strings.ContainsAny(v, ";{= ") { + return "{" + v + "}", nil + } + return v, nil +} + +// convertToDB2DSN converts URL format to DB2 DSN format. +func convertToDB2DSN(dsn string) (string, error) { + // If it's already in DB2 format (contains HOSTNAME= or DATABASE=), return as-is. + // URL-format DSNs are exempt from this check so those markers may appear in credentials. + if !strings.HasPrefix(dsn, "db2://") && (strings.Contains(dsn, "HOSTNAME=") || strings.Contains(dsn, "DATABASE=")) { + return dsn, nil + } + + parsedURL, err := url.Parse(dsn) + if err != nil { + return "", fmt.Errorf("invalid DSN format: %w", err) + } + + if parsedURL.Scheme != "db2" { + return "", fmt.Errorf("expected db2:// scheme, got %s", parsedURL.Scheme) + } + + hostname := parsedURL.Hostname() + port := parsedURL.Port() + if port == "" { + port = "50000" // Default DB2 port + } + + database := strings.TrimPrefix(parsedURL.Path, "/") + if database == "" { + return "", fmt.Errorf("database name is required in DSN path") + } + quotedDatabase, err := quoteDB2Value(database) + if err != nil { + return "", fmt.Errorf("invalid database name: %w", err) + } + + var username, password string + if parsedURL.User != nil { + username = parsedURL.User.Username() + password, _ = parsedURL.User.Password() + } + + // Build DB2 DSN format + // HOSTNAME=SERVER_NAME;PORT=DB_PORT;DATABASE=DATABASE_NAME;UID=USER_ID;PWD=PASSWORD + var dsnParts []string + dsnParts = append(dsnParts, fmt.Sprintf("HOSTNAME=%s", hostname)) + dsnParts = append(dsnParts, fmt.Sprintf("DATABASE=%s", quotedDatabase)) + dsnParts = append(dsnParts, fmt.Sprintf("PORT=%s", port)) + dsnParts = append(dsnParts, "PROTOCOL=TCPIP") + + if username != "" { + quoted, err := quoteDB2Value(username) + if err != nil { + return "", fmt.Errorf("invalid username: %w", err) + } + dsnParts = append(dsnParts, fmt.Sprintf("UID=%s", quoted)) + } + if password != "" { + quoted, err := quoteDB2Value(password) + if err != nil { + return "", fmt.Errorf("invalid password: %w", err) + } + dsnParts = append(dsnParts, fmt.Sprintf("PWD=%s", quoted)) + } + + // Forward URL query parameters as additional DB2 DSN keywords (e.g. + // ?SECURITY=SSL), sorted for deterministic output. + params := parsedURL.Query() + keys := make([]string, 0, len(params)) + for key := range params { + keys = append(keys, key) + } + sort.Strings(keys) + seen := make(map[string]bool, len(keys)) + for _, key := range keys { + keyword := strings.ToUpper(key) + if strings.ContainsAny(keyword, ";={}") { + return "", fmt.Errorf("invalid connection parameter name %q", key) + } + if reservedDSNKeywords[keyword] { + return "", fmt.Errorf("connection parameter %q conflicts with a reserved DSN keyword; use the native DB2 DSN format instead", key) + } + values := params[key] + if len(values) != 1 || seen[keyword] { + return "", fmt.Errorf("connection parameter %q specified multiple times", key) + } + seen[keyword] = true + quoted, err := quoteDB2Value(values[0]) + if err != nil { + return "", fmt.Errorf("invalid value for connection parameter %q: %w", key, err) + } + dsnParts = append(dsnParts, fmt.Sprintf("%s=%s", keyword, quoted)) + } + + return strings.Join(dsnParts, ";"), nil +} diff --git a/pkg/database/db2/dsn_test.go b/pkg/database/db2/dsn_test.go new file mode 100644 index 00000000..13cfe431 --- /dev/null +++ b/pkg/database/db2/dsn_test.go @@ -0,0 +1,94 @@ +package db2 + +import ( + "testing" + + "github.com/stretchr/testify/require" +) + +func TestConvertToDB2DSN(t *testing.T) { + tests := []struct { + name string + dsn string + want string + wantErr string + }{ + { + name: "url with credentials and port", + dsn: "db2://user:pass@dbhost:50001/testdb", + want: "HOSTNAME=dbhost;DATABASE=testdb;PORT=50001;PROTOCOL=TCPIP;UID=user;PWD=pass", + }, + { + name: "url without port uses default", + dsn: "db2://dbhost/testdb", + want: "HOSTNAME=dbhost;DATABASE=testdb;PORT=50000;PROTOCOL=TCPIP", + }, + { + name: "native dsn passed through", + dsn: "HOSTNAME=dbhost;PORT=50000;DATABASE=testdb;UID=user;PWD=pass", + want: "HOSTNAME=dbhost;PORT=50000;DATABASE=testdb;UID=user;PWD=pass", + }, + { + name: "wrong scheme", + dsn: "postgres://dbhost/testdb", + wantErr: "expected db2:// scheme", + }, + { + name: "missing database name", + dsn: "db2://dbhost:50000", + wantErr: "database name is required", + }, + { + name: "password with semicolon is brace-quoted", + dsn: "db2://user:my;pass@dbhost:50000/testdb", + want: "HOSTNAME=dbhost;DATABASE=testdb;PORT=50000;PROTOCOL=TCPIP;UID=user;PWD={my;pass}", + }, + { + name: "url-encoded password decoded then brace-quoted", + dsn: "db2://user:p%3Bss%20word@dbhost:50000/testdb", + want: "HOSTNAME=dbhost;DATABASE=testdb;PORT=50000;PROTOCOL=TCPIP;UID=user;PWD={p;ss word}", + }, + { + name: "password with closing brace rejected", + dsn: "db2://user:pa%7Dss@dbhost:50000/testdb", + wantErr: "invalid password", + }, + { + name: "query parameters colliding after uppercasing rejected", + dsn: "db2://user:pass@dbhost:50000/testdb?security=SSL&SECURITY=NONE", + wantErr: "specified multiple times", + }, + { + name: "url dsn containing native marker in password still parsed as url", + dsn: "db2://user:DATABASE=x@dbhost:50000/testdb", + want: "HOSTNAME=dbhost;DATABASE=testdb;PORT=50000;PROTOCOL=TCPIP;UID=user;PWD={DATABASE=x}", + }, + { + name: "query parameters forwarded as keywords sorted", + dsn: "db2://user:pass@dbhost:50000/testdb?Security=SSL&CurrentSchema=MYSCHEMA", + want: "HOSTNAME=dbhost;DATABASE=testdb;PORT=50000;PROTOCOL=TCPIP;UID=user;PWD=pass;CURRENTSCHEMA=MYSCHEMA;SECURITY=SSL", + }, + { + name: "query parameter overriding reserved keyword rejected", + dsn: "db2://user:pass@dbhost:50000/testdb?uid=other", + wantErr: "conflicts with a reserved DSN keyword", + }, + { + name: "duplicate query parameter rejected", + dsn: "db2://user:pass@dbhost:50000/testdb?Security=SSL&Security=NONE", + wantErr: "specified multiple times", + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + got, err := convertToDB2DSN(tt.dsn) + if tt.wantErr != "" { + require.ErrorContains(t, err, tt.wantErr) + return + } + require.NoError(t, err) + require.Equal(t, tt.want, got) + }) + } +} diff --git a/vendor/github.com/ibmdb/go_ibm_db/.gitignore b/vendor/github.com/ibmdb/go_ibm_db/.gitignore new file mode 100644 index 00000000..90b47531 --- /dev/null +++ b/vendor/github.com/ibmdb/go_ibm_db/.gitignore @@ -0,0 +1,5 @@ +syntax:glob +*.exe +*.orig + +syntax:regexp diff --git a/vendor/github.com/ibmdb/go_ibm_db/API_DOCUMENTATION.md b/vendor/github.com/ibmdb/go_ibm_db/API_DOCUMENTATION.md new file mode 100644 index 00000000..c90470de --- /dev/null +++ b/vendor/github.com/ibmdb/go_ibm_db/API_DOCUMENTATION.md @@ -0,0 +1,494 @@ +# go-ibm_db API Documentation + +## Database APIs + +**APIs for creating and dropping Database using Go application** + +* [.CreateDb(dbName,connectionString,options...)](#CreateDb) +* [.DropDb(dbName,connectionString)](#DropDb) + +**Database APIs** + +1. [.Open(drivername,ConnectionString)](#OpenApi) +2. [.Prepare(sqlquery)](#PrepareApi) +3. [.Query(sqlquery)](#QueryApi) +4. [.Exec(sqlquery)](#ExecApi) +5. [.Begin()](#BeginApi) +6. [.Close()](#CloseApi) +7. [.Commit()](#CommitApi) +8. [.Rollback()](#RollbackApi) +9. [.QueryRow(sqlquery)](#QueryRowApi) +10. [.Columns()](#ColumnsApi) +11. [.Next()](#NextApi) +12. [.Scan(options)](#ScanApi) +13. [.Init(N,connStr)](#InitApi) +14. [.SetConnMaxLifetime(N)](#SetConnMaxLifetimeApi) + +### 1) .Open(drivername,ConnectionString) + +open a connection to database +* **connectionString** - The connection string for your database. +* For distributed platforms, the connection string is typically defined as: `DATABASE=dbname;HOSTNAME=hostname;PORT=port;PROTOCOL=TCPIP;UID=username;PWD=passwd` + +```go +var connStr = flag.String("conn", "HOSTNAME=hostname;PORT=port;DATABASE=dbname;UID=uid;PWD=Pass", "connection string") + +func dboper() error { + fmt.Println("connecting to driver") + db, err := sql.Open("drivername", *connStr) + if err != nil { + return err + } + + defer db.Close() +} +``` +### 2) .Prepare(sqlquery) + +Prepare a statement for execution +* **sql** - SQL string to prepare + +Returns a ‘statement’ object + +```go +func oper() error { + fmt.Println("connecting to go-ibm_db") + db, err := sql.Open("go-ibm_db", *connStr) + if err != nil { + return err + } + + defer db.Close() + + st, err := db.Prepare("select * from ak") + if err != nil { + return err + } + + rows, err := st.Query() + if err != nil { + return err + } + + defer rows.Close() +} +``` + +### 3) .Query(sqlquery) + +Issue a SQL query to the database + +If the query is executed then it will return the rows or it will return error + +```go +func oper() error { + fmt.Println("connecting to go-ibm_db") + db, err := sql.Open("go-ibm_db", *connStr) + if err != nil { + return err + } + + defer db.Close() + + rows, err := db.Query("select * from ak") + if err != nil { + return err + } + + defer rows.Close() +} +``` + + +### 4) .Exec(sqlquery) + +Execute a prepared statement. + +Only DML commands are performed. No data is returned back. + +```go +func oper() error { + fmt.Println("connecting to go-ibm_db") + db, err := sql.Open("go-ibm_db", *connStr) + if err != nil { + return err + } + + defer db.Close() + + _, err = db.Exec("create table ghh(a int, b float, c double, d char, e varchar(30))") + if err != nil { + return err + } +} +``` + +### 5) .Begin() + +Begin a transaction. + +```go +func oper() error { + fmt.Println("connecting to go-ibm_db") + db, err := sql.Open("go-ibm_db", *connStr) + if err != nil { + return err + } + + defer db.Close() + + bg, err := db.Begin() + if err != nil { + return err + } + + return nil +} +``` + + + +### 6) .Close() + +Close the currently opened database. + +```go +func dboper() error { + fmt.Println("connecting to go-ibm_db") + db, err := sql.Open("go-ibm_db", *connStr) + if err != nil { + return err + } + + defer db.Close() +} +``` + +### 7) .Commit() + +Commit a transaction. + +```go +func oper() error { + fmt.Println("connecting to go-ibm_db") + db, err := sql.Open("go-ibm_db", *connStr) + if err != nil { + return err + } + + defer db.Close() + + bg, err := db.Begin() + if err != nil { + return err + } + + _, err = bg.Exec("create table ghh(a int,b float,c double,d char,e varchar(30))") + if err != nil { + return err + } + + err = bg.Commit() + if err != nil { + return err + } + + return nil +} +``` + + + + +### 8) .Rollback() + +Rollback a transaction. + +```go +func oper() error { + fmt.Println("connecting to go-ibm_db") + db, err := sql.Open("go-ibm_db", *connStr) + if err != nil { + return err + } + + defer db.Close() + bg, err := db.Begin() + if err != nil { + return err + } + + _, err = bg.Exec("create table ghh(a int,b float,c double,d char,e varchar(30))") + if err != nil { + return err + } + + err = bg.Rollback() + if err != nil { + return err + } + + return nil +} +``` + +### 9) .QueryRow(sqlquery) + +QueryRow executes a query that is expected to return at most one row. +If there are more rows then it will scan first and discards the rest. + +```go +func oper() error { + id := 123 + var username string + err := db.QueryRow("SELECT name FROM ak WHERE id=?", id).Scan(&username) + if err != nil { + return err + } + + fmt.Printf("Username is %s\n", username) + return nil +} +``` + +### 10) .Columns() + +Returns the column names. + +Returns error if the rows are closed. + +```go +func oper() error { + fmt.Println("connecting to database") + db, err := sql.Open("go-ibm_db", *connStr) + if err != nil { + return err + } + + defer db.Close() + + st, err := db.Prepare("select * from ak") + if err != nil { + return err + } + + rows, err := st.Query() + if err != nil { + return err + } + + defer rows.Close() + name11 := make([]string, 1) + name11, err = rows.Columns() + fmt.Printf("%v", name11) + return nil +} +``` + +### 11) .Next() + +Prepares the next result row for reading with the scan api. + +```go +func oper() error { + fmt.Println("connecting to database") + db, err := sql.Open("go-ibm_db", *connStr) + if err != nil { + return err + } + defer db.Close() + + rows, err := db.Query() + if err != nil { + return err + } + defer rows.Close() + + for rows.Next() { + var t string + var x string + err = rows.Scan(&t, &x) + if err != nil { + return err + } + + fmt.Printf("%v %v\n", t, x) + } + + return nil +} +``` + +### 12) .Scan(options) + +copies the columns in the current row into the values pointed. + +```go +func oper() error { + fmt.Println("connecting to database") + db, err := sql.Open("go-ibm_db", *connStr) + if err != nil { + return err + } + defer db.Close() + + rows, err := db.Query() + if err != nil { + return err + } + defer rows.Close() + + for rows.Next() { + var t string + var x string + err = rows.Scan(&t, &x) + if err != nil { + return err + } + + fmt.Printf("%v %v\n", t, x) + } + return nil +} +``` + +### 13) .Init(N,connStr) + +Initialize Pool with N no of active connections using supplied connection string. It is a synchronous API. We do not need an asynchronous version of this API. +* **N** - No of connections to be initialized. +* **connStr** - The connection string for your database +```go +func oper() error { + fmt.Println("connecting to database") + + var ret = pool.init(5, connStr) + if ret != true { + fmt.Println(ret) + } + + db := pool.Open(connStr, "SetConnMaxLifetime=10") + for i:=0; i<20; i++ { + db := pool.Open(con, "SetConnMaxLifetime=10") + if db != nil { + st, err := db.Prepare("select * from SAMPLE") + if err != nil { + fmt.Println("Error: ", err) + } else { + go func() { + ExecQuery(st) + db.Close() + }() + } + } + } + + time.Sleep(30*time.Second) + pool.Release() + return nil +} +func ExecQuery(st *sql.Stmt) error { + res, err := st5.Query() + if err != nil { + fmt.Println(err) + } + cols, _ := res.Columns() + + fmt.Printf("%s %s %s %s\n", cols[0], cols[1], cols[2], cols[3]) + defer res.Close() + for res.Next() { + var t, x, m, n string + err = res.Scan(&t, &x, &m, &n) + fmt.Printf("%v %v %v %v\n", t, x, m, n) + } + return nil +} +``` + +### 14) .SetConnMaxLifetime(T) + +Set the maximum length of time a connection can held open before it is closed. +* **T** - Maximum lenght of time the connection can held open. + +```go +func oper() error { + fmt.Println("connecting to database")a + + pool.SetConnMaxLifetime(10) + ret := pool.Init(3, con) + if ret != true { + fmt.Println(ret) + } + return nil +} +``` + +## Create and Drop Database APIs + +### .CreateDb(dbName, connectionString, options...) + +To create a database (dbName) through Go application. + +* **dbName** - The database name. +* **connectionString** - The connection string for your database instance. +* **options** - _OPTIONAL_ - string type + * codeset - Database code set information. + * mode - Database logging mode (applicable only to "IDS data servers"). + +```go +package main + +import ( + "database/sql" + "fmt" + "github.com/ibmdb/go_ibm_db" +) + +func main() { + var conStr = "HOSTNAME=hostname;PORT=port;PROTOCOL=TCPIP;UID=username;PWD=password" + var dbName = "Goo" + res, err := go_ibm_db.CreateDb(dbName, conStr) + // CreateDb with options + //go_ibm_db.CreateDb(dbName, conStr, "codeset=UTF-8", "mode=value") + if err != nil { + fmt.Println("Error while creating database ", err) + } + if res { + fmt.Println("Database created successfully.") + conStr = conStr + ";" + "DATABASE=" + dbName + db, err := sql.Open("go_ibm_db", conStr) + if err = db.Ping(); err != nil { + fmt.Println("Ping Error: ", err) + } + defer db.Close() + fmt.Println("Connected: ok") + } +} +``` + +### .DropDb(dbName, connectionString) + +To drop a database (dbName) through Go application. + +* **dbName** - The database name. +* **connectionString** - The connection string for your database instance. + +```go +package main + +import ( + "fmt" + "github.com/ibmdb/go_ibm_db" +) + +func main() { + var conStr = "HOSTNAME=hostname;PORT=port;PROTOCOL=TCPIP;UID=username;PWD=password" + var dbName = "Goo" + res, err := go_ibm_db.DropDb(dbName, conStr) + if err != nil { + fmt.Println("Error while dropping database ", err) + } + if res { + fmt.Println("Database dropped successfully.") + } +} +``` diff --git a/vendor/github.com/ibmdb/go_ibm_db/CHANGES.md b/vendor/github.com/ibmdb/go_ibm_db/CHANGES.md new file mode 100644 index 00000000..a40bbd87 --- /dev/null +++ b/vendor/github.com/ibmdb/go_ibm_db/CHANGES.md @@ -0,0 +1,303 @@ +2024-12-11, Version 0.5.2 +========================= + + * doc: update installation and SSL connection info (Bimal Jha) + + * update: install script and install.md doc (Bimal Jha) + + +2024-12-10, Version 0.5.1 +========================= + + * update: go version in mod and workflows files (Bimal Jha) + + * fea: add support for Macos AMR64 platform (Bimal Jha) + + * Update Go Lang version (#254) (VIKAS MATHUR) + + +2024-09-06, Version 0.5.0 +========================= + + * Update DB Create and Drop testcase (#253) (VIKAS MATHUR) + + * Update Pooling testcases (#252) (VIKAS MATHUR) + + * update workflow file for test (Bimal Jha) + + * Update go.yml (VIKAS MATHUR) + + * fix connection issue in github action (Bimal Jha) + + * fix spacing issue by replacing tab with 4spaces (Bimal Jha) + + * Support for logging (#251) (VIKAS MATHUR) + + * Update actions (#248) (hydernaqvi) + + * Updated all testcase with error check (#249) (VIKAS MATHUR) + + * Code alignment (#244) (VIKAS MATHUR) + + * Logs at API Level (#241) (VIKAS MATHUR) + + * Cleanup Files and README (#240) (hydernaqvi) + + * z/OS Initial Port (#239) (hydernaqvi) + + * fix issue #236 Decimal value by instering as string, columnSize should be of maximum decimal precision (#237) (sirius) + + * doc: update Readme file (Bimal Jha) + + +2023-11-23, Version 0.4.5 +========================= + + * Add env var for cli driver download url (#229) (Andrew Becher) + + * Enhance Go driver to read Db2 credentials form Evn for testing (#226) (VIKAS MATHUR) + + * Decimal value by instering as string (#223) (VIKAS MATHUR) + + +2023-07-05, Version 0.4.4 +========================= + + * Fix for SQL_DECIMAL type uses comma as separator (#219) (VIKAS MATHUR) + + * Added INSTALL.md file and new testcases (#216) (VIKAS MATHUR) + + * Fix: pass integer values into SQLSetEnvAttr and SQLSetConnectAttr (#215) (Andrew Becher) + + * Updated README.md and changed default buffer read length for varchar field (#213) (VIKAS MATHUR) + + +2023-03-29, Version 0.4.3 +========================= + + * Fixing Release Handle (#204) (alexcocia) + + * Added db2level check before installing clidriver (#193) (VIKAS MATHUR) + + * Fix issue #200 index out of range (#201) (VIKAS MATHUR) + + * Added new testcases (#197) (VIKAS MATHUR) + + * Added new testcases (#195) (VIKAS MATHUR) + + * Updated ExecContext and QueryContext functions (#190) (VIKAS MATHUR) + + * Change in handling of os.LookupEnv (#188) (VIKAS MATHUR) + + +2022-10-25, Version 0.4.2 +========================= + + * Change IBM_DB2_HOME to IBM_DB_HOME (Bimal Kumar Jha) + + * Document corrections (Vikas Mathur) + + * Fix handling of os.LookupEnv return code in installer (Eric Newsom) + + * Changed environment variable name DB2HOME to IBM_DB_HOME (Bimal Kumar Jha) + + * Updated review comment (Vikas Mathur) + + * Changed env variable name DB2HOME to IBM_DB_HOME (Vikas Mathur) + + * Connection Pooling Enhancement to create connection in advance (Bimal Kumar Jha) + + * Added pooling with limit on the number of connetions example (Vikas Mathur) + + * Update API_DOCUMENTATION.md (VIKAS MATHUR) + + * Documented the new APIs (Vikas Mathur) + + * Addressed code review commments (Vikas Mathur) + + * Connection Pooling - Address review comment (Vikas Mathur) + + * Updated Connection Pooling (Vikas Mathur) + + * Added Context methods (Vikas Mathur) + + * Updated Golang install version (Vikas Mathur) + + * Addressed review comments (Vikas Mathur) + + * Updated for Docker Linux Container (Vikas Mathur) + + * Script file to set environment variables (Vikas Mathur) + + * Script file to set enviornment variables (Vikas Mathur) + + * Support for version 1.17 (Vikas Mathur) + + * Updated concurrent map write on the pool (Vikas Mathur) + + * Updated Library Path and fix decimal column type error (Vikas Mathur) + + * Update ExecDirect_test.go (yyt) + + * #126 fix (Ravuri Sai Ram Akhil) + + * error msg changed for when using db.Query (Ravuri Sai Ram Akhil) + + +2021-04-08, Version 0.4.1 +========================= + + * GOARCh changed from 390 to s390x (Ravuri Sai Ram Akhil) + + +2021-03-17, Version 0.4.0 +========================= + + * Readme updated to 1.16 (Ravuri Sai Ram Akhil) + + * Readme changed for 1.16 (Ravuri Sai Ram Akhil) + + * Clidriver Dowload location updated to support go1.16 (Ravuri Sai Ram Akhil) + + * println is removed (Ravuri Sai Ram Akhil) + + * Precision and Scale changed Decimal and Numeric (Ravuri Sai Ram Akhil) + + * Decimal value fix #116 (Ravuri Sai Ram Akhil) + + * Fix an additional typo. (David Mooney) + + * Run gofmt on API docs. (David Mooney) + + * Run gofmt on README code samples. (David Mooney) + + * Fix Misspell clidriver (Apipol Sukgler) + + * setup.go support AIX. (yunbozh) + + * Improve comment (alejandro.labad) + + * Improved solution as it is done by sql.go (alejandro.labad) + + * Propose solution for parametrized queries (alejandro.labad) + + * Fix issue # 100 where store procedure output parameters was being truncated. (Rajesh Jayakumar) + + * Support for aix (rahul-shinge) + + +2020-06-02, Version 0.3.0 +========================= + + * ExecDirect test case added (Ravuri Sai Ram Akhil) + + * queryRow testcase updated and Direct Execute api added (Ravuri Sai Ram Akhil) + + * Allow null insertion to some binary data types (Santiago De la Cruz) + + * License requiements added (Ravuri Sai Ram Akhil) + + * Readme updated with <= in versions (Ravuri Sai Ram Akhil) + + * Readme updated with new line after versions (Ravuri Sai Ram Akhil) + + * Readme updated with versions (Ravuri Sai Ram Akhil) + + * Set 1 for default year, month and day SQL_C_TYPE_TIME (Santiago De la Cruz) + + * c_decfloat is removed (Ravuri Sai Ram Akhil) + + * Don't create a variable for len of data binding []byte (Santiago De la Cruz) + + * Don't get pointer of inexistent index when data is empty binding []byte (Santiago De la Cruz) + + * XML datatype support (Santiago De la Cruz) + + * DCFLOAT SUPPORT FOR WINDOWS AND NON WINDOWS (Ravuri Sai Ram Akhil) + + * Send size of LONG VARCHAR (Santiago De la Cruz) + + * added fmt package (Santiago De la Cruz) + + * Avoid register the driver when panic (Santiago De la Cruz) + + * Update bug_report.md (Santiago De la Cruz) + + * Update issue templates (Akhil Ravuri) + + * Connection attribute link added (Ravuri Sai Ram Akhil) + + * Connection attribute link added and create db options are defined. (Ravuri Sai Ram Akhil) + + * comment on how to use options in createDb api (Ravuri Sai Ram Akhil) + + * Documentation for admin operations (Ravuri Sai Ram Akhil) + + * Create database and Drop database api support (Ravuri Sai Ram Akhil) + + +2019-10-17, Version 0.2.0 +========================= + + * changed query length from SQLINTEGER to SQLNTS (Ravuri Sai Ram Akhil) + + * sql_int added in prepare (Ravuri Sai Ram Akhil) + + * sqlnts added (Ravuri Sai Ram Akhil) + + * added sql_nts in prepare (Ravuri Sai Ram Akhil) + + * Boolean support for latest server (Ravuri Sai Ram Akhil) + + * input and output parametr is added for linux (Ravuri Sai Ram Akhil) + + * main connection string changed (Ravuri Sai Ram Akhil) + + * sp InOut support and array insert support (Ravuri Sai Ram Akhil) + + +2019-09-09, Version 0.1.1 +========================= + + * readme, null terminator modified and 2GB spported (Ravuri Sai Ram Akhil) + + * readme updated (Ravuri Sai Ram Akhil) + + * Removed extra bytes stored for char in sql.Out (Ravuri Sai Ram Akhil) + + * readme updated for linux2 (Ravuri Sai Ram Akhil) + + * Support for OUT type in Stored Procedure (Ravuri Sai Ram Akhil) + + * Now Clob supports 2GB (Ravuri Sai Ram Akhil) + + * null terminator has been added (Ravuri Sai Ram Akhil) + + * null terminator has been removed (Ravuri Sai Ram Akhil) + + * null termination added for utf16 to fix binvalue error for an empty variable (Ravuri Sai Ram Akhil) + + * pooling code updated (Ravuri Sai Ram Akhil) + + +2019-05-22, Version 0.1.0 +========================= + + * SQLColAttributes,HasNextResultSet has been supported (Ravuri Sai Ram Akhil) + + * CLOB datatype is supported (Ravuri Sai Ram Akhil) + + * String termination modified (Ravuri Sai Ram Akhil) + + * fix for ';' issue (Ravuri Sai Ram Akhil) + + +2019-05-10, Version 0.0.1 +========================= + + + +2019-05-10, Version 0.0.0 +========================= + + * First release! diff --git a/vendor/github.com/ibmdb/go_ibm_db/CONTRIBUTING.md b/vendor/github.com/ibmdb/go_ibm_db/CONTRIBUTING.md new file mode 100644 index 00000000..41c33769 --- /dev/null +++ b/vendor/github.com/ibmdb/go_ibm_db/CONTRIBUTING.md @@ -0,0 +1,11 @@ +# Developer's Certificate of Origin 1.1 + +By making a contribution to this project, I certify that: + +(a) The contribution was created in whole or in part by me and I have the right to submit it under the open source license indicated in the file; or + +(b) The contribution is based upon previous work that, to the best of my knowledge, is covered under an appropriate open source license and I have the right under that license to submit that work with modifications, whether created in whole or in part by me, under the same open source license (unless I am permitted to submit under a different license), as indicated in the file; or + +(c) The contribution was provided directly to me by some other person who certified (a), (b) or (c) and I have not modified it. + +(d) I understand and agree that this project and the contribution are public and that a record of the contribution (including all personal information I submit with it, including my sign-off) is maintained indefinitely and may be redistributed consistent with this project or the open source license(s) involved. \ No newline at end of file diff --git a/vendor/github.com/ibmdb/go_ibm_db/INSTALL.md b/vendor/github.com/ibmdb/go_ibm_db/INSTALL.md new file mode 100644 index 00000000..b2786cbc --- /dev/null +++ b/vendor/github.com/ibmdb/go_ibm_db/INSTALL.md @@ -0,0 +1,239 @@ +# Installing go_ibm_db + +*Copyright (c) 2014 IBM Corporation and/or its affiliates. All rights reserved.* + +Permission is hereby granted, free of charge, to any person obtaining a copy of this +software and associated documentation files (the "Software"), to deal in the Software +without restriction, including without limitation the rights to use, copy, modify, +merge, publish, distribute, sublicense, and/or sell copies of the Software, +and to permit persons to whom the Software is furnished to do so, subject to the +following conditions: + +The above copyright notice and this permission notice shall be included in all copies +or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +DEALINGS IN THE SOFTWARE. + +## Contents + +1. [Overview](#Installation) +2. [ibm_db Installation on Linux](#inslnx) +3. [ibm_db Installation on MacOS](#insmac) +4. [ibm_db Installation on Windows](#inswin) + +## 1. Overview + +The [*go_ibm_db*](https://github.com/ibmdb/go_ibm_db) is an asynchronous/synchronous interface for GoLang to IBM DB2. + +Following are the steps to installation in your system. + +This go_ibm_db driver has been tested on 64-bit/32-bit IBM Linux, MacOS and Windows. + +### 1.1 clidriver info for MacOS + +* Latest version of clidriver available for MacOS x64 system is: v11.5.9 +* By default on Intel Chip Macos, clidriver of v11.5.9 will get downloaded. +* First version of clidriver supported on MacOS ARM64 system is: v12.1.0 +* On MacOS M1/M2/M3 Chip system, by default clidriver of v12.1.0 will get downloaded. + +### 1.2 License requirement to connect to Db2 for z/OS and Db2 for iSeries servers + +* Please read [this doc](https://github.com/ibmdb/go_ibm_db/blob/master/README.md#for-zos-and-iseries-connectivity-and-sql1598n-error) for detail info about license requiremnet and resolving SQL1598N error during connection. +* clidriver v12.1.0 requires db2connect v12.1 license to connect z/OS or iSeries severs. +* MacOS Silicon Chip (arm64 processor) is supported using v12.1 clidriver only and hence require db2connect v12.1 license. +* You can force go_ibm_db driver to use older version of clidirver by setting system level environment varialbe CLIDRIVER_DOWNLOAD_VERSION or explicitly setting IBM_DB_DOWNLOAD_URL to point path of clidriver.tar.gz file. +``` + export CLIDRIVER_DOWNLOAD_VERSION=v11.5.9 + export IBM_DB_DOWNLOAD_URL=https://public.dhe.ibm.com/ibmdl/export/pub/software/data/db2/drivers/odbc_cli/v11.5.9/linuxx64_odbc_cli.tar.gz + go run setup.go +``` + +## 2. Go_ibm_db Installation on Linux. + +### 2.1 Install GoLang for Linux + +Download the +[GoLang Linux binaries](https://golang.org/dl) or [Go Latest binaries](https://go.dev/dl) and +extract the file, for example into `$HOME/mygo`: + +``` +cd $HOME/mygo +wget -c https://golang.org/dl/go1.22.1.linux-amd64.tar.gz +tar -xzf go1.22.1.linux-amd64.tar.gz +export GOROOT=$HOME/mygo/go +export GOPATH=$HOME/mygo +``` + +Set PATH to include Go: + +``` +export PATH=/mygo/go/bin:$PATH +``` + +### 2.2 Install go_ibm_db + +Following are the steps to install [*go_ibm_db*](https://github.com/ibmdb/go_ibm_db) from github. +using directory `/goapp` for example. + +#### 2.2.1 Direct Installation. +``` +1. mkdir goapp +2. cd goapp +3. go install github.com/ibmdb/go_ibm_db/installer@latest + or + go install github.com/ibmdb/go_ibm_db/installer@v0.5.2 +4. ls $GOPATH/pkg/mod/github.com/ibmdb + go_ibm_db@v0.5.2 +5. cd $GOPATH/pkg/mod/github.com/ibmdb/go_ibm_db@v0.5.2/installer +6. go run ./setup.go +7. export IBM_DB_HOME=$GOPATH/pkg/mod/github.com/ibmdb/clidriver +8. source ./setenv.sh +``` + +It's Done. + +#### 2.2.2 Manual Installation by using git clone. + +``` +1. mkdir $HOME/goapp +2. cd goapp +3. git clone https://github.com/ibmdb/go_ibm_db/ +4. go env GOPATH +5. cd go_ibm_db/installer +6. go run ./setup.go +7. export IBM_DB_HOME=$HOME/goapp/clidriver +8. source ./setenv.sh +``` + +If IBM_DB_HOME is already set or, sourcing setenv.sh fails, create below environment variables: +``` +export CGO_CFLAGS=-I$IBM_DB_HOME/include +export CGO_LDFLAGS=-L$IBM_DB_HOME/lib +export LD_LIBRARY_PATH=$IBM_DB_HOME/lib:$LD_LIBRARY_PATH +``` + +## 3. Go_ibm_db Installation on MacOS x64 and arm64 Systems + +### 3.1 Install GoLang for Mac + +Download the +[GoLang MacOS binaries](https://golang.org/dl) or [GoLang Latest binaries](https://go.dev/dl) and +extract the file. + +### 3.2 Install go_ibm_db + +#### 3.2.1 Direct Installation. +``` +1. mkdir goapp +2. cd goapp +3. go install github.com/ibmdb/go_ibm_db/installer@latest + or + go install github.com/ibmdb/go_ibm_db/installer@v0.5.2 +4. go env GOPATH +5. cd $GOPATH/pkg/mod/github.com/ibmdb/go_ibm_db@v0.5.2/installer +6. go run setup.go +7. export IBM_DB_HOME=$GOPATH/pkg/mod/github.com/ibmdb/clidriver +8. source ./setenv.sh +``` + +It's Done. + +#### 3.2.2 Manual Installation by using git clone. +``` +1. mkdir goapp +2. cd goapp +3. git clone https://github.com/ibmdb/go_ibm_db/ +4. cd go_ibm_db/installer +5. go run setup.go +6. source ./setenv.sh +7. cd ../testdata +8. Edit config.json file and update database connection info, save it. +9. go mod init testdata +10. go mod tidy +11. go run main.go +``` + +### 3.3 Set environment variables to clidriver directory path + +#### 3.3.1 Manual +``` +export IBM_DB_HOME=/home/uname/clidriver +export CGO_CFLAGS=-I$IBM_DB_HOME/include +export CGO_LDFLAGS=-L$IBM_DB_HOME/lib +export DYLD_LIBRARY_PATH=$DYLD_LIBRARY_PATH:$IBM_DB_HOME/lib +``` + +#### 3.3.2 Script file +``` +cd .../go_ibm_db/installer +source setenv.sh +``` + +#### 3.3.3 Disable SIP or create symlink of libdb2 on MacARM64 sysem + +* New MacOS systems comes with System Integrity Protection(SIP) enabled which discards setting of DYLD_LIBRARY_PATH env variable +* Disable SIP if your Go app gives error that: file `libdb2.dylib` not found. +* OR, if you can not disable SIP, create softlink of `.../clidriver/lib/libdb2.dylib` file under your applications home directory. +``` + ln -s .../clidriver/lib/libdb2.dylib libdb2.dylib +``` +* OR, if you see `libdb2.dylib` file under `go_ibm_db` directory, you can copy it too in your app root directory. + +## 4. Go_ibm_db Installation on Windows. + +### 4.1 Install GoLang for Windows + +Download the [Go Windows binary/installer](https://golang.org/dl) or [Go Latest binaries](https://go.dev/dl/) and +install it. + +### 4.2 Install go_ibm_db + +Following are the steps to install [*go_ibm_db*](https://github.com/ibmdb/go_ibm_db) from github. +using directory `/goapp` for example. + +#### 4.2.1 Direct Installation. +``` +1. mkdir goapp +2. cd gopapp +3. go install github.com/ibmdb/go_ibm_db/installer@latest + or + go install github.com/ibmdb/go_ibm_db/installer@v0.5.2 +4. go env GOPATH +5. cd %GOPATH%\pkg\mod\github.com\ibmdb\go_ibm_db@v0.5.2\installer +6. go run setup.go +7. + set IBM_DB_HOME=%GOPATH%\pkg\mod\github.com\ibmdb\clidriver + set CGO_CFLAGS=-I%IBM_DB_HOME%\include + set CGO_LDFLAGS=-L%IBM_DB_HOME%\lib + set LIB=%IBM_DB_HOME%\lib;%LIB% +``` + +#### 4.2.2 Manual Installation by using git clone. +``` +1. mkdir %HOME%\goapp +2. cd goapp +3. git clone https://github.com/ibmdb/go_ibm_db/ +4. go env GOPATH +5. cd go_ibm_db\installer +6. go run setup.go +7. + set IBM_DB_HOME=%HOME%\goapp\clidriver + set CGO_CFLAGS=-I%IBM_DB_HOME%\include + set CGO_LDFLAGS=-L%IBM_DB_HOME%\lib + set LIB=%IBM_DB_HOME%\lib;%LIB% +``` + +### 4.3 Script file +``` +cd .../go_ibm_db/installer +Run setenvwin.bat +``` +It's Done. + +4. Download platform specific clidriver from https://public.dhe.ibm.com/ibmdl/export/pub/software/data/db2/drivers/odbc_cli/ , untar/unzip it and set `IBM_DB_HOME` environmental variable to full path of extracted 'clidriver' directory, for example if clidriver is extracted as: `/home/mysystem/clidriver`, then set system level environment variable `IBM_DB_HOME=/home/mysystem/clidriver`. + diff --git a/vendor/github.com/ibmdb/go_ibm_db/LICENSE.md b/vendor/github.com/ibmdb/go_ibm_db/LICENSE.md new file mode 100644 index 00000000..60a01d61 --- /dev/null +++ b/vendor/github.com/ibmdb/go_ibm_db/LICENSE.md @@ -0,0 +1,27 @@ +Copyright (c) 2024 The Go Authors. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright +notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above +copyright notice, this list of conditions and the following disclaimer +in the documentation and/or other materials provided with the +distribution. + * Neither the name of Google Inc. nor the names of its +contributors may be used to endorse or promote products derived from +this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/vendor/github.com/ibmdb/go_ibm_db/README.md b/vendor/github.com/ibmdb/go_ibm_db/README.md new file mode 100644 index 00000000..8b012943 --- /dev/null +++ b/vendor/github.com/ibmdb/go_ibm_db/README.md @@ -0,0 +1,566 @@ +# go_ibm_db + +Interface for GoLang to `DB2 for z/OS`, `DB2 for LUW` and `DB2 for i` database servers. + +## API Documentation + +> For complete list of go_ibm_db APIs and examples please check [APIDocumentation.md](https://github.com/ibmdb/go_ibm_db/blob/master/API_DOCUMENTATION.md) + +## Prerequisite + +- Golang should be installed(Golang version should be >=1.12.x and <= 1.23.X) + +- Git should be installed in your system. + +- For non-windows users, GCC and tar should be present in your system. + +- For Docker Linux Container(Ex: Amazon Linux2), use below commands: +``` +yum install go git tar libpam +``` +### Note: +* Environment variable `DB2HOME` is changed to `IBM_DB_HOME`. + +* **SQL1598N Error** - It is expected in absence of valid db2connect license. Please click [here](#for-zos-and-iseries-connectivity-and-sql1598n-error) and read instructions about license requirement and how to apply the license. + +* go_ibm_db@v0.5.1 is the last version to download v11.5.9 clidriver by defualt and first version to support MacOS arm64 platform using v12.1.0 clidriver. +* There is no MacOS Intel Chip clidriver from v12.1.0 onwards. + +## How to Install in Windows + +- You may install go_ibm_db using either of below commands + +``` +go get -d github.com/ibmdb/go_ibm_db +go install github.com/ibmdb/go_ibm_db/installer@latest +go install github.com/ibmdb/go_ibm_db/installer@v0.5.2 +``` + +- You can optionally specify a specific cli driver by setting the IBM_DB_DOWNLOAD_URL environment variable +to the full path of your desired cli driver. For example, if you want to install the 64-bit macos v11.5.4 +cli driver instead of the latest one, set the variable as below: +``` +export IBM_DB_DOWNLOAD_URL=https://public.dhe.ibm.com/ibmdl/export/pub/software/data/db2/drivers/odbc_cli/v11.5.4/macos64_odbc_cli.tar.gz +``` + +- You can instruct go_ibm_db driver to download specific version of clidriver by setting environment variable `CLIDRIVER_DOWNLOAD_VERSION=` before running `setup.go` file. f.e. `export CLIDRIVER_DOWNLOAD_VERSION=v11.5.9` + +- If you already have a dsdriver/db2client/db2server or clidriver with include directory available in your system, add the path of the same to your +PATH windows environment variable. +Example: +``` + set PATH="C:\Program Files\IBM\IBM DATA SERVER DRIVER\bin";%PATH% + set LIB="C:\Program Files\IBM\IBM DATA SERVER DRIVER\lib";%LIB% +``` + +- Note that the `clidriver` or Runtime Client (RTCL) downloaded from IBM Fix Central do not have `include` directory and do not work with `go_ibm_db` driver. Download `IBM Data Sever Driver Package` or `IBM Data Server Client` (CLNT) from fix central and install. + +- If you do not have a clidriver in your system, go to installer folder where `go_ibm_db` +is downloaded in your system, use below command: +(Example: C:\Users\uname\go\src\github.com\ibmdb\go_ibm_db\installer + or C:\Users\uname\go\pkg\mod\github.com\ibmdb\go_ibm_db\installer + where uname is the username ) and run setup.go file (`go run setup.go`). + setup.go file will automatically download clidriver from IBM hosted site under parent directory of go_ibm_db. + +``` +Set IBM_DB_HOME to clidriver downloaded path and +set this path to your PATH windows environment variable +(Example: Path=C:\Users\uname\go\src\github.com\ibmdb\clidriver) +set IBM_DB_HOME=C:\Users\uname\go\src\github.com\ibmdb\clidriver +set PATH=%IBM_DB_HOME%\bin;%PATH% +set LIB=%IBM_DB_HOME%\lib;%LIB% +set CGO_CFLAGS=%IBM_DB_HOME%\include +set CGO_LDFLAGS=%IBM_DB_HOME%\bin +``` + +- Script file to set environment variable +``` +cd .../go_ibm_db/installer +setenvwin.bat +``` + +## How to Install in Linux/Mac + +- You may install go_ibm_db using either of below commands + +``` +go get -d github.com/ibmdb/go_ibm_db +go install github.com/ibmdb/go_ibm_db/installer@latest +go install github.com/ibmdb/go_ibm_db/installer@v0.5.2 +``` + +Please check https://github.com/ibmdb/go_ibm_db/blob/master/INSTALL.md for detailed installation instructions. + +- For Docker Linux Container, use below commands: +``` +yum install -y gcc git go wget tar xz make gcc-c++ +cd /root +curl -OL https://golang.org/dl/go1.23.4.linux-amd64.tar.gz +tar -C /usr/local -xzf go1.23.4.linux-amd64.tar.gz + +rm /usr/bin/go +rm /usr/bin/gofmt +cp /usr/local/go/bin/go /usr/bin/ +cp /usr/local/go/bin/gofmt /usr/bin/ + +go install github.com/ibmdb/go_ibm_db/installer@latest +``` + +## How to Install in z/OS + +- You may install go_ibm_db using the below command + +``` +go install github.com/ibmdb/go_ibm_db/installer@latest +``` + +### Configure ODBC driver on z/OS + +> **Note** +> You must have the following environment variables set. +> * IBM_DB_HOME +> * STEPLIB +> * DSNAOINI + + +Please refer to the [ODBC Guide and References](https://www.ibm.com/support/knowledgecenter/SSEPEK/pdf/db2z_12_odbcbook.pdf) cookbook for how to configure your ODBC driver. Specifically, you need to ensure you have: + +1. Apply Db2 on z/OS PTF [UI60551](https://www-01.ibm.com/support/docview.wss?uid=swg1PH05953) to pick up new ODBC functionality to support Node.js applications. + +2. Binded the ODBC packages. A sample JCL is provided in the `SDSNSAMP` dataset in member `DSNTIJCL`. Customize the JCL with specifics to your system. + +3. Set the `IBM_DB_HOME` environment variable to the High Level Qualifier (HLQ) of your Db2 datasets. For example, if your Db2 datasets are located as `DSNC10.SDSNC.H` and `DSNC10.SDSNMACS`, you need to set `IBM_DB_HOME` environment variable to `DSNC10` with the following statement (can be saved in `~/.profile`): + + ```sh + # Set HLQ to Db2 datasets. + export IBM_DB_HOME="DSNC10" + ``` + +4. Update the `STEPLIB` environment variable to include the Db2 SDSNEXIT, SDSNLOAD and SDSNLOD2 data sets. You can set the `STEPLIB` environment variable with the following statement, after defining `IBM_DB_HOME` to the high level qualifier of your Db2 datasets as instructed above: + + ```sh + # Assumes IBM_DB_HOME specifies the HLQ of the Db2 datasets. + export STEPLIB=$STEPLIB:$IBM_DB_HOME.SDSNEXIT:$IBM_DB_HOME.SDSNLOAD:$IBM_DB_HOME.SDSNLOD2 + ``` + +5. Configured an appropriate _Db2 ODBC initialization file_ that can be read at application time. You can specify the file by using either a DSNAOINI data definition statement or by defining a `DSNAOINI` z/OS UNIX environment variable. For compatibility with ibm_db, the following properties must be set: + + In COMMON section: + + ``` + MULTICONTEXT=2 + CURRENTAPPENSCH=ASCII + FLOAT=IEEE + ``` + + In SUBSYSTEM section: + + ``` + MVSATTACHTYPE=RRSAF + ``` + + Here is a sample of a complete initialization file: + + ``` + ; This is a comment line... + ; Example COMMON stanza + [COMMON] + MVSDEFAULTSSID=VC1A + CONNECTTYPE=1 + MULTICONTEXT=2 + CURRENTAPPENSCH=ASCII + FLOAT=IEEE + ; Example SUBSYSTEM stanza for VC1A subsystem + [VC1A] + MVSATTACHTYPE=RRSAF + PLANNAME=DSNACLI + ; Example DATA SOURCE stanza for STLEC1 data source + [STLEC1] + AUTOCOMMIT=1 + CURSORHOLD=1 + ``` + +Here's a simple script you can run setup your ODBC INI file. +The following script exepcts that you have have defined your subsystem in following way: + +```export SUBSYSTEM=``` + +This script will setup your inistialization file. + +```shell +export DSNAOINI="$HOME/ODBC_${HOSTNAME}_${SUBSYSTEM}_CAF" +touch $DSNAOINI +/bin/cat /dev/null > "$DSNAOINI" +/bin/chtag -t -c 1047 "$DSNAOINI" +_BPXK_AUTOCVT=ON /bin/cat <"$DSNAOINI" +[COMMON] +MVSDEFAULTSSID=$SUBSYSTEM +CURRENTAPPENSCH=UNICODE +FLOAT=IEEE +[$SUBSYSTEM] +MVSATTACHTYPE=CAF +PLANNAME=DSNACLI +[$HOSTNAME$SUBSYSTEM] +AUTOCOMMIT=1 +EOF +``` + + Reference Chapter 3 in the [ODBC Guide and References](https://www.ibm.com/support/knowledgecenter/SSEPEK/pdf/db2z_12_odbcbook.pdf) for more instructions. + + +## For z/OS and iSeries Connectivity and SQL1598N error + +- Connection to `Db2 for z/OS` or `Db2 for i`(AS400) Server using `ibm_db` driver from distributed platforms (Linux, Unix, Windows and MacOS) is not free. It requires either client side or server side license. + +- Connection to `Db2 for LUW` or `Informix` Server using `ibm_db` driver is free. + +- `ibm_db` returns SQL1598N error in absence of a valid db2connect license. SQL1598N error is returned by the Db2 Server to client. +To suppress this error, Db2 server must be activated with db2connectactivate utility OR a client side db2connect license file must exist. + +- Db2connect license can be applied on database server or client side. A **db2connect license of version 11.5** is required for go_ibm_db. + +- For MacOS M1/M2/M3 Chip System (ARM64 processor), db2connect license of version **12.1** is required for go_ibm_db. + +- For activating server side license, you can purchase either `Db2 Connect Unlimited Edition for System z®` or `Db2 Connect Unlimited Edition for System i®` license from IBM. + +- Ask your DBA to run db2connectactivate utility on Server to activate db2connect license. + +- If database Server is enabled for db2connect, no need to apply client side db2connect license. + +- If Db2 Server is not db2connectactivated to accept unlimited number of client connection, you must need to apply client side db2connect license. + +- db2connectactivate utility and client side db2connect license both comes together from IBM in a single zip file. + +- Client side db2connect license is a `db2con*.lic` file that must be copied under `clidriver\license` directory. + +- If you have a `db2jcc_license_cisuz.jar` file, it will not work for ibm_db. `db2jcc_license_cisuz.jar` is a db2connect license file for Java Driver. For non-Java Driver, client side db2connect license comes as a file name `db2con*.lic`. + +- If environment variable `IBM_DB_HOME` or `IBM_DB_INSTALLER_URL` is not set, `ibm_db` automatically downloads [open source driver specific clidriver](https://public.dhe.ibm.com/ibmdl/export/pub/software/data/db2/drivers/odbc_cli/) and save as `github.com/ibmdb/clidriver`. Ignores any other installation. + +- If `IBM_DB_HOME` or `IBM_DB_INSTALLER_URL` is set, you need to have same version of db2connect license as installed db2 client. Check db2 client version using `db2level` command to know version of db2connect license required. The license file should get copied under `$IBM_DB_HOME\license` directory. + +- If you do not have db2connect license, contact [IBM Customer Support](https://www.ibm.com/mysupport/s/?language=en_US) to buy db2connect license. Find the `db2con*.lic` file in the db2connect license shared by IBM and copy it under `.../github.com/ibmdb/clidriver/license` directory or `$IBM_DB_HOME/license` directory if `IBM_DB_HOME` is set. + +- To know more about license and purchasing cost, please contact [IBM Customer Support](https://www.ibm.com/mysupport/s/?language=en_US). + +- To know more about server based licensing viz db2connectactivate, follow below links: +* [Activating the license certificate file for Db2 Connect Unlimited Edition](https://www.ibm.com/docs/en/db2/11.5?topic=li-activating-license-certificate-file-db2-connect-unlimited-edition). +* [Unlimited licensing using db2connectactivate utility](https://www.ibm.com/docs/en/db2/11.1?topic=edition-db2connectactivate-server-license-activation-utility). + +## How to run sample program + +### example1.go:- + +```go +package main + +import ( + "database/sql" + "fmt" + _ "github.com/ibmdb/go_ibm_db" +) + +func main() { + con := "HOSTNAME=host;DATABASE=name;PORT=number;UID=username;PWD=password" + db, err := sql.Open("go_ibm_db", con) + if err != nil { + fmt.Println(err) + } + db.Close() +} +``` +To run the sample:- go run example1.go + +For complete list of connection parameters please check [this.](https://www.ibm.com/docs/en/db2/11.5?topic=file-data-server-driver-configuration-keywords) + +### example2.go:- + +```go +package main + +import ( + "database/sql" + "fmt" + _ "github.com/ibmdb/go_ibm_db" +) + +func Create_Con(con string) *sql.DB { + db, err := sql.Open("go_ibm_db", con) + if err != nil { + fmt.Println(err) + return nil + } + return db +} + +// Creating a table. + +func create(db *sql.DB) error { + _, err := db.Exec("DROP table SAMPLE") + if err != nil { + _, err := db.Exec("create table SAMPLE(ID varchar(20),NAME varchar(20),LOCATION varchar(20),POSITION varchar(20))") + if err != nil { + return err + } + } else { + _, err := db.Exec("create table SAMPLE(ID varchar(20),NAME varchar(20),LOCATION varchar(20),POSITION varchar(20))") + if err != nil { + return err + } + } + fmt.Println("TABLE CREATED") + return nil +} + +// Inserting row. + +func insert(db *sql.DB) error { + st, err := db.Prepare("Insert into SAMPLE(ID,NAME,LOCATION,POSITION) values('3242','Mike','Hyderabad','Manager')") + if err != nil { + return err + } + st.Query() + return nil +} + +// This API selects the data from the table and prints it. + +func display(db *sql.DB) error { + st, err := db.Prepare("select * from SAMPLE") + if err != nil { + return err + } + err = execquery(st) + if err != nil { + return err + } + return nil +} + +func execquery(st *sql.Stmt) error { + rows, err := st.Query() + if err != nil { + return err + } + cols, _ := rows.Columns() + fmt.Printf("%s %s %s %s\n", cols[0], cols[1], cols[2], cols[3]) + fmt.Println("-------------------------------------") + defer rows.Close() + for rows.Next() { + var t, x, m, n string + err = rows.Scan(&t, &x, &m, &n) + if err != nil { + return err + } + fmt.Printf("%v %v %v %v\n", t, x, m, n) + } + return nil +} + +func main() { + con := "HOSTNAME=host;DATABASE=name;PORT=number;UID=username;PWD=password" + type Db *sql.DB + var re Db + re = Create_Con(con) + err := create(re) + if err != nil { + fmt.Println(err) + } + err = insert(re) + if err != nil { + fmt.Println(err) + } + err = display(re) + if err != nil { + fmt.Println(err) + } +} +``` +To run the sample:- go run example2.go + +### example3.go:-(POOLING) + +```go +package main + +import ( + _ "database/sql" + "fmt" + a "github.com/ibmdb/go_ibm_db" +) + +func main() { + // Defining connection string + // Depending on your connection type + // you may wish to add: MULTICONTEXT=0 + con := "HOSTNAME=host;PORT=number;DATABASE=name;UID=username;PWD=password" + pool := a.Pconnect("PoolSize=100") + + // SetConnMaxLifetime will take the value in SECONDS + db := pool.Open(con, "SetConnMaxLifetime=30") + st, err := db.Prepare("Insert into SAMPLE values('hi','hi','hi','hi')") + if err != nil { + fmt.Println(err) + } + st.Query() + + // Here the time out is default. + db1 := pool.Open(con) + st1, err := db1.Prepare("Insert into SAMPLE values('hi1','hi1','hi1','hi1')") + if err != nil { + fmt.Println(err) + } + st1.Query() + + db1.Close() + db.Close() + pool.Release() + fmt.Println("success") +} +``` +To run the sample:- go run example3.go + +### example4.go:-(POOLING- Limit on the number of connections) + +```go +package main + +import ( + "database/sql" + "fmt" + "time" + a "github.com/ibmdb/go_ibm_db" + ) + +func ExecQuery(st *sql.Stmt) error { + res, err := st.Query() + if err != nil { + fmt.Println(err) + } + cols, _ := res.Columns() + + fmt.Printf("%s %s %s %s\n", cols[0], cols[1], cols[2], cols[3]) + defer res.Close() + for res.Next() { + var t, x, m, n string + err = res.Scan(&t, &x, &m, &n) + fmt.Printf("%v %v %v %v\n", t, x, m, n) + } + return nil +} + +func main() { + con := "HOSTNAME=host;PORT=number;DATABASE=name;UID=username;PWD=password" + pool := a.Pconnect("PoolSize=5") + + ret := pool.Init(5, con) + if ret != true { + fmt.Println("Pool initializtion failed") + } + + for i:=0; i<20; i++ { + db1 := pool.Open(con, "SetConnMaxLifetime=10") + if db1 != nil { + st1, err1 := db1.Prepare("select * from VMSAMPLE") + if err1 != nil { + fmt.Println("err1 : ", err1) + }else{ + go func() { + ExecQuery(st1) + db1.Close() + }() + } + } + } + time.Sleep(30*time.Second) + pool.Release() +} +``` +To run the sample:- go run example4.go + +For Running the Tests: +====================== + +* Connection information must be specified in the environment variables +``` +For example, by sourcing the following ENV variables: +export DB2_DATABASE= +export DB2_USER= +export DB2_PASSWD= +export DB2_HOSTNAME= +export DB2_PORT= +``` + +* OR +``` +If not using environment variables, update connection information in +go_ibm_db/testdata/config.json file. +``` + +* Now run go test command (use go test -v command for details) + +* To run a particular test case (use "go test sample_test.go main.go", example "go test Arraystring_test.go main.go") + +For Secure Database Connection using SSL/TSL +============================================ + +> go_ibm_db supports secure connection to Database Server over SSL same as ODBC/CLI driver. If you have SSL Certificate from server or an CA signed certificate, just use it in connection string as below: + +``` +connStr := "DATABASE=database;HOSTNAME=hostname;PORT=port;Security=SSL;SSLServerCertificate=;PROTOCOL=TCPIP;UID=username;PWD=passwd;"; +``` +> Note the two extra keywords **Security** and **SSLServerCertificate** used in connection string. `SSLServerCertificate` should point to the SSL Certificate from server or an CA signed certificate. Also, `PORT` must be `SSL` port and not the TCPI/IP port. Make sure Db2 server is configured to accept connection on SSL port else `go_ibm_db` will throw SQL30081N error. + +> Value of `SSLServerCertificate` keyword must be full path of a certificate file generated for client authentication. + It normally has `*.arm` or `*.cert` or `*.pem` extension. `ibm_db` do not support `*.jks` format file as it is not a + certificate file but a Java KeyStore file, extract certificate from it using keytool and then use the cert file. + +> `go_ibm_db` uses IBM ODBC/CLI Driver for connectivity and it do not support a `*.jks` file as keystoredb as `keystore.jks` is meant for Java applications. + Note that `*.jks` file is a `Java Key Store` file and it is not an SSL Certificate file. You can extract SSL certificate from JKS file using below `keytool` command: + ``` + keytool -exportcert -alias your_certificate_alias -file client_cert.cert -keystore keystore.jks + ``` + Now, you can use the generated `client_cert.cert` as the value of `SSLServerCertificate` in connection string. + +> `go_ibm_db` supports only ODBC/CLI Driver keywords in connection string: https://www.ibm.com/docs/en/db2/11.5?topic=odbc-cliodbc-configuration-keywords + +> Do not use keyworkds like `sslConnection=true` in connection string as it is a JDBC connection keyword and go_ibm_db + ignores it. Corresponding ibm_db connection keyword for `sslConnection` is `Security` hence, use `Security=SSL;` in + connection string instead. + +* To connect to dashDB in IBM Cloud, use below connection string: +``` +connStr = "DATABASE=database;HOSTNAME=hostname;PORT=port;PROTOCOL=TCPIP;UID=username;PWD=passwd;Security=SSL" +``` +> We just need to add **Security=SSL** in connection string to have a secure connection against Db2 server in IBM Cloud. + +**Note:** You can also create a KeyStore DB using GSKit command line tool and use it in connection string along with other keywords as documented in [DB2 Infocenter](http://www.ibm.com/support/knowledgecenter/en/SSEPGG_11.5.0/com.ibm.db2.luw.admin.sec.doc/doc/t0053518.html). + +If you have created a KeyStore DB using GSKit using password or you have got *.kdb file with *.sth file, use +connection string in below format: +``` +connStr = "DATABASE=database;HOSTNAME=hostname;PORT=port;PROTOCOL=TCPIP;UID=dbuser;PWD=db2pwd;" + + "Security=SSL;SslClientKeystoredb=C:/client.kdb;SSLClientKeystash=C:/client.sth;" +OR, +connStr = "DATABASE=database;HOSTNAME=hostname;PORT=port;PROTOCOL=TCPIP;UID=dbuser;PWD=db2pwd;" + + "Security=SSL;SslClientKeystoredb=C:/client.kdb;SSLClientKeystoreDBPassword=kdbpasswd;" +``` + +> If you have downloaded `IBMCertTrustStore` from IBM site, ibm_db will not work with it; you need to + download `Secure Connection Certificates.zip` file that comes for IBM DB2 Command line tool(CLP). + `Secure Connection Certificates.zip` has *.kdb and *.sth files that should be used as the value of + `SSLClientKeystoreDB` and `SSLClientKeystash` in connection string. + +Logging: +======== + +* You may enable logging in the go_ibm_db module to trace activities. Logging can be directed to be console or a specified file. + +``` +# Log on console: +go run sample.go -trace + +# Log to a file (e.g., log.txt) +go run sample.go -trace log.txt + +``` diff --git a/vendor/github.com/ibmdb/go_ibm_db/api/Makefile b/vendor/github.com/ibmdb/go_ibm_db/api/Makefile new file mode 100644 index 00000000..2bdd2559 --- /dev/null +++ b/vendor/github.com/ibmdb/go_ibm_db/api/Makefile @@ -0,0 +1,15 @@ +# Copyright 2012 The Go Authors. All rights reserved. +# Use of this source code is governed by a BSD-style +# license that can be found in the LICENSE file. + +all: zapi_windows.go zapi_unix.go + +zapi_windows.go: api.go + $(GOROOT)/src/pkg/syscall/mksyscall_windows.pl $^ \ + | gofmt \ + > $@ + +zapi_unix.go: api.go + ./mksyscall_unix.pl $^ \ + | gofmt \ + > $@ diff --git a/vendor/github.com/ibmdb/go_ibm_db/api/api.go b/vendor/github.com/ibmdb/go_ibm_db/api/api.go new file mode 100644 index 00000000..eb31855f --- /dev/null +++ b/vendor/github.com/ibmdb/go_ibm_db/api/api.go @@ -0,0 +1,116 @@ +// Copyright 2012 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package api + +import ( + "unicode/utf16" + "unsafe" + "runtime" + trc "github.com/ibmdb/go_ibm_db/log2" + "fmt" +) + +type ( + SQL_DATE_STRUCT struct { + Year SQLSMALLINT + Month SQLUSMALLINT + Day SQLUSMALLINT + } + + SQL_TIMESTAMP_STRUCT struct { + Year SQLSMALLINT + Month SQLUSMALLINT + Day SQLUSMALLINT + Hour SQLUSMALLINT + Minute SQLUSMALLINT + Second SQLUSMALLINT + Fraction SQLUINTEGER + } + SQL_TIME_STRUCT struct { + Hour SQLUSMALLINT + Minute SQLUSMALLINT + Second SQLUSMALLINT + } +) + +//sys SQLAllocHandle(handleType SQLSMALLINT, inputHandle SQLHANDLE, outputHandle *SQLHANDLE) (ret SQLRETURN) = odbc32.SQLAllocHandle +//sys SQLBindCol(statementHandle SQLHSTMT, columnNumber SQLUSMALLINT, targetType SQLSMALLINT, targetValuePtr SQLPOINTER, bufferLength SQLLEN, vallen *SQLLEN) (ret SQLRETURN) = odbc32.SQLBindCol +//sys SQLBindParameter(statementHandle SQLHSTMT, parameterNumber SQLUSMALLINT, inputOutputType SQLSMALLINT, valueType SQLSMALLINT, parameterType SQLSMALLINT, columnSize SQLULEN, decimalDigits SQLSMALLINT, parameterValue SQLPOINTER, bufferLength SQLLEN, ind *SQLLEN) (ret SQLRETURN) = odbc32.SQLBindParameter +//sys SQLCloseCursor(statementHandle SQLHSTMT) (ret SQLRETURN) = odbc32.SQLCloseCursor +//sys SQLDescribeCol(statementHandle SQLHSTMT, columnNumber SQLUSMALLINT, columnName *SQLWCHAR, bufferLength SQLSMALLINT, nameLengthPtr *SQLSMALLINT, dataTypePtr *SQLSMALLINT, columnSizePtr *SQLULEN, decimalDigitsPtr *SQLSMALLINT, nullablePtr *SQLSMALLINT) (ret SQLRETURN) = odbc32.SQLDescribeColW +//sys SQLDescribeParam(statementHandle SQLHSTMT, parameterNumber SQLUSMALLINT, dataTypePtr *SQLSMALLINT, parameterSizePtr *SQLULEN, decimalDigitsPtr *SQLSMALLINT, nullablePtr *SQLSMALLINT) (ret SQLRETURN) = odbc32.SQLDescribeParam +//sys SQLDisconnect(connectionHandle SQLHDBC) (ret SQLRETURN) = odbc32.SQLDisconnect +//sys SQLDriverConnect(connectionHandle SQLHDBC, windowHandle SQLHWND, inConnectionString *SQLWCHAR, stringLength1 SQLSMALLINT, outConnectionString *SQLWCHAR, bufferLength SQLSMALLINT, stringLength2Ptr *SQLSMALLINT, driverCompletion SQLUSMALLINT) (ret SQLRETURN) = odbc32.SQLDriverConnectW +//sys SQLEndTran(handleType SQLSMALLINT, handle SQLHANDLE, completionType SQLSMALLINT) (ret SQLRETURN) = odbc32.SQLEndTran +//sys SQLExecute(statementHandle SQLHSTMT) (ret SQLRETURN) = odbc32.SQLExecute +//sys SQLFetch(statementHandle SQLHSTMT) (ret SQLRETURN) = odbc32.SQLFetch +//sys SQLFreeHandle(handleType SQLSMALLINT, handle SQLHANDLE) (ret SQLRETURN) = odbc32.SQLFreeHandle +//sys SQLGetData(statementHandle SQLHSTMT, colOrParamNum SQLUSMALLINT, targetType SQLSMALLINT, targetValuePtr SQLPOINTER, bufferLength SQLLEN, vallen *SQLLEN) (ret SQLRETURN) = odbc32.SQLGetData +//sys SQLGetDiagRec(handleType SQLSMALLINT, handle SQLHANDLE, recNumber SQLSMALLINT, sqlState *SQLWCHAR, nativeErrorPtr *SQLINTEGER, messageText *SQLWCHAR, bufferLength SQLSMALLINT, textLengthPtr *SQLSMALLINT) (ret SQLRETURN) = odbc32.SQLGetDiagRecW +//sys SQLNumParams(statementHandle SQLHSTMT, parameterCountPtr *SQLSMALLINT) (ret SQLRETURN) = odbc32.SQLNumParams +//sys SQLNumResultCols(statementHandle SQLHSTMT, columnCountPtr *SQLSMALLINT) (ret SQLRETURN) = odbc32.SQLNumResultCols +//sys SQLPrepare(statementHandle SQLHSTMT, statementText *SQLWCHAR, textLength SQLINTEGER) (ret SQLRETURN) = odbc32.SQLPrepareW +//sys SQLRowCount(statementHandle SQLHSTMT, rowCountPtr *SQLLEN) (ret SQLRETURN) = odbc32.SQLRowCount +//sys SQLSetEnvAttr(environmentHandle SQLHENV, attribute SQLINTEGER, valuePtr SQLPOINTER, stringLength SQLINTEGER) (ret SQLRETURN) = odbc32.SQLSetEnvAttr +//sys SQLSetConnectAttr(connectionHandle SQLHDBC, attribute SQLINTEGER, valuePtr SQLPOINTER, stringLength SQLINTEGER) (ret SQLRETURN) = odbc32.SQLSetConnectAttrW + +// UTF16ToString returns the UTF-8 encoding of the UTF-16 sequence s, +// with a terminating NUL removed. +func UTF16ToString(s []uint16) string { + trc.Trace1("api/api.go UTF16ToString() - ENTRY") + for i, v := range s { + if v == 0 { + s = s[0:i] + break + } + } + trc.Trace1("api/api.go UTF16ToString() - EXIT") + return string(utf16.Decode(s)) +} + +// StringToUTF16 returns the UTF-16 encoding of the UTF-8 string s, +// with a terminating NUL added. +//func StringToUTF16(s string) []uint16 { return utf16.Encode([]rune(s + "\u0000")) } +func StringToUTF16(s string) []uint16 { + trc.Trace1("api/api.go StringToUTF16()") + trc.Trace1(fmt.Sprintf("api/api.go StringToUTF16() - s = %s", s)) + + if runtime.GOOS == "zos"{ + return utf16.Encode([]rune(s)) + }else { + return utf16.Encode([]rune(s + "\u0000")) + } +} + + +// StringToUTF16Ptr returns pointer to the UTF-16 encoding of +// the UTF-8 string s, with a terminating NUL added. +func StringToUTF16Ptr(s string) *uint16 { return &StringToUTF16(s)[0] } + +// ExtractUTF16Str uses unsafe package to copy UTF16 string to a byte slice. +func ExtractUTF16Str(s []uint16) []byte { + trc.Trace1("api/api.go ExtractUTF16Str() - ENTRY") + + var out []byte + for i := range s { + b := Extract(unsafe.Pointer(&s[i]), unsafe.Sizeof(s[i])) + out = append(out, b...) + } + + trc.Trace1("api/api.go ExtractUTF16Str() - EXIT") + return out +} + +func Extract(ptr unsafe.Pointer, size uintptr) []byte { + trc.Trace1("api/api.go Extract() - ENTRY") + + out := make([]byte, size) + for i := range out { + out[i] = *((*byte)(unsafe.Pointer(uintptr(ptr) + uintptr(i)))) + } + + trc.Trace1("api/api.go Extract() - EXIT") + return out +} diff --git a/vendor/github.com/ibmdb/go_ibm_db/api/api_unix.go b/vendor/github.com/ibmdb/go_ibm_db/api/api_unix.go new file mode 100644 index 00000000..ee7b9db2 --- /dev/null +++ b/vendor/github.com/ibmdb/go_ibm_db/api/api_unix.go @@ -0,0 +1,199 @@ +// Copyright 2012 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +//go:build (aix || darwin || linux) && cgo +// +build aix darwin linux +// +build cgo + +package api + +import ( + trc "github.com/ibmdb/go_ibm_db/log2" + "fmt" +) + +// #cgo aix LDFLAGS: -ldb2 +// #cgo darwin LDFLAGS: -ldb2 +// #cgo linux LDFLAGS: -ldb2 +// #include +// #include +/* +SQLRETURN sqlSetEnvUIntPtrAttr(SQLHENV environmentHandle, SQLINTEGER attribute, uintptr_t valuePtr, SQLINTEGER stringLength) { + return SQLSetEnvAttr(environmentHandle, attribute, (SQLPOINTER)valuePtr, stringLength); +} + +SQLRETURN sqlSetConnectUIntPtrAttr(SQLHDBC connectionHandle, SQLINTEGER attribute, uintptr_t valuePtr, SQLINTEGER stringLength) { + return SQLSetConnectAttr(connectionHandle, attribute, (SQLPOINTER)valuePtr, stringLength); +} +*/ +import "C" + +const ( + SQL_OV_ODBC3 = uintptr(C.SQL_OV_ODBC3) + + SQL_ATTR_ODBC_VERSION = C.SQL_ATTR_ODBC_VERSION + + SQL_DRIVER_NOPROMPT = C.SQL_DRIVER_NOPROMPT + + SQL_HANDLE_ENV = C.SQL_HANDLE_ENV + SQL_HANDLE_DBC = C.SQL_HANDLE_DBC + SQL_HANDLE_STMT = C.SQL_HANDLE_STMT + + SQL_SUCCESS = C.SQL_SUCCESS + SQL_SUCCESS_WITH_INFO = C.SQL_SUCCESS_WITH_INFO + SQL_INVALID_HANDLE = C.SQL_INVALID_HANDLE + SQL_NO_DATA = C.SQL_NO_DATA + SQL_NO_TOTAL = C.SQL_NO_TOTAL + SQL_NTS = C.SQL_NTS + SQL_MAX_MESSAGE_LENGTH = C.SQL_MAX_MESSAGE_LENGTH + SQL_NULL_HANDLE = uintptr(C.SQL_NULL_HANDLE) + SQL_NULL_HENV = uintptr(C.SQL_NULL_HENV) + SQL_NULL_HDBC = uintptr(C.SQL_NULL_HDBC) + SQL_NULL_HSTMT = uintptr(C.SQL_NULL_HSTMT) + + SQL_PARAM_INPUT = C.SQL_PARAM_INPUT + SQL_PARAM_OUTPUT = C.SQL_PARAM_OUTPUT + SQL_PARAM_INPUT_OUTPUT = C.SQL_PARAM_INPUT_OUTPUT + + SQL_NULL_DATA = C.SQL_NULL_DATA + SQL_DATA_AT_EXEC = C.SQL_DATA_AT_EXEC + + SQL_UNKNOWN_TYPE = C.SQL_UNKNOWN_TYPE + SQL_CHAR = C.SQL_CHAR + SQL_NUMERIC = C.SQL_NUMERIC + SQL_DECIMAL = C.SQL_DECIMAL + SQL_INTEGER = C.SQL_INTEGER + SQL_SMALLINT = C.SQL_SMALLINT + SQL_FLOAT = C.SQL_FLOAT + SQL_REAL = C.SQL_REAL + SQL_DOUBLE = C.SQL_DOUBLE + SQL_DATETIME = C.SQL_DATETIME + SQL_DATE = C.SQL_DATE + SQL_TIME = C.SQL_TIME + SQL_VARCHAR = C.SQL_VARCHAR + SQL_TYPE_DATE = C.SQL_TYPE_DATE + SQL_TYPE_TIME = C.SQL_TYPE_TIME + SQL_TYPE_TIMESTAMP = C.SQL_TYPE_TIMESTAMP + SQL_TIMESTAMP = C.SQL_TIMESTAMP + SQL_LONGVARCHAR = C.SQL_LONGVARCHAR + SQL_BINARY = C.SQL_BINARY + SQL_VARBINARY = C.SQL_VARBINARY + SQL_LONGVARBINARY = C.SQL_LONGVARBINARY + SQL_BIGINT = C.SQL_BIGINT + SQL_TINYINT = C.SQL_TINYINT + SQL_BIT = C.SQL_BIT + SQL_WCHAR = C.SQL_WCHAR + SQL_WVARCHAR = C.SQL_WVARCHAR + SQL_WLONGVARCHAR = C.SQL_WLONGVARCHAR + SQL_GUID = C.SQL_GUID + SQL_BLOB = C.SQL_BLOB + SQL_CLOB = C.SQL_CLOB + SQL_SIGNED_OFFSET = C.SQL_SIGNED_OFFSET + SQL_UNSIGNED_OFFSET = C.SQL_UNSIGNED_OFFSET + SQL_DBCLOB = C.SQL_DBCLOB + SQL_BOOLEAN = C.SQL_BOOLEAN + SQL_XML = C.SQL_XML + + // TODO(lukemauldin): Not defined in sqlext.h. Using windows value, but it is not supported. + SQL_SS_XML = -152 + + SQL_C_CHAR = C.SQL_C_CHAR + SQL_C_LONG = C.SQL_C_LONG + SQL_C_SHORT = C.SQL_C_SHORT + SQL_C_FLOAT = C.SQL_C_FLOAT + SQL_C_DOUBLE = C.SQL_C_DOUBLE + SQL_C_NUMERIC = C.SQL_C_NUMERIC + SQL_C_DATE = C.SQL_C_DATE + SQL_C_TIME = C.SQL_C_TIME + SQL_C_TYPE_TIMESTAMP = C.SQL_C_TYPE_TIMESTAMP + SQL_C_TIMESTAMP = C.SQL_C_TIMESTAMP + SQL_C_BINARY = C.SQL_C_BINARY + SQL_C_BIT = C.SQL_C_BIT + SQL_C_WCHAR = C.SQL_C_WCHAR + SQL_C_DEFAULT = C.SQL_C_DEFAULT + SQL_C_SBIGINT = C.SQL_C_SBIGINT + SQL_C_UBIGINT = C.SQL_C_UBIGINT + SQL_C_GUID = C.SQL_C_GUID + SQL_C_DBCHAR = C.SQL_C_DBCHAR + SQL_C_TYPE_DATE = C.SQL_C_TYPE_DATE + SQL_C_TYPE_TIME = C.SQL_C_TYPE_TIME + SQL_C_XML = C.SQL_XML + + SQL_COMMIT = C.SQL_COMMIT + SQL_ROLLBACK = C.SQL_ROLLBACK + + SQL_AUTOCOMMIT = C.SQL_AUTOCOMMIT + SQL_ATTR_AUTOCOMMIT = C.SQL_ATTR_AUTOCOMMIT + SQL_AUTOCOMMIT_OFF = C.SQL_AUTOCOMMIT_OFF + SQL_AUTOCOMMIT_ON = C.SQL_AUTOCOMMIT_ON + SQL_AUTOCOMMIT_DEFAULT = C.SQL_AUTOCOMMIT_DEFAULT + SQL_DESC_PRECISION = C.SQL_DESC_PRECISION + SQL_DESC_SCALE = C.SQL_DESC_SCALE + SQL_DESC_LENGTH = C.SQL_DESC_LENGTH + SQL_DESC_CONCISE_TYPE = C.SQL_DESC_CONCISE_TYPE + SQL_DESC_TYPE_NAME = C.SQL_DESC_TYPE_NAME + SQL_COLUMN_TYPE = C.SQL_COLUMN_TYPE + SQL_COLUMN_TYPE_NAME = C.SQL_COLUMN_TYPE_NAME + MAX_FIELD_SIZE = 1024 + SQL_DESC_NULLABLE = C.SQL_DESC_NULLABLE + SQL_NULLABLE = C.SQL_NULLABLE + SQL_NO_NULLS = C.SQL_NO_NULLS + SQL_DECFLOAT = C.SQL_DECFLOAT + SQL_ATTR_PARAMSET_SIZE = C.SQL_ATTR_PARAMSET_SIZE + + SQL_IS_UINTEGER = C.SQL_IS_UINTEGER + SQL_IS_INTEGER = C.SQL_IS_INTEGER + + //Connection pooling + SQL_ATTR_CONNECTION_POOLING = C.SQL_ATTR_CONNECTION_POOLING + SQL_ATTR_CP_MATCH = C.SQL_ATTR_CP_MATCH + SQL_CP_OFF = uintptr(C.SQL_CP_OFF) + SQL_CP_ONE_PER_DRIVER = uintptr(C.SQL_CP_ONE_PER_DRIVER) + SQL_CP_ONE_PER_HENV = uintptr(C.SQL_CP_ONE_PER_HENV) + SQL_CP_DEFAULT = SQL_CP_OFF + SQL_CP_STRICT_MATCH = uintptr(C.SQL_CP_STRICT_MATCH) + SQL_CP_RELAXED_MATCH = uintptr(C.SQL_CP_RELAXED_MATCH) +) + +type ( + SQLHANDLE C.SQLHANDLE + SQLHENV C.SQLHENV + SQLHDBC C.SQLHDBC + SQLHSTMT C.SQLHSTMT + SQLHWND uintptr + + SQLWCHAR C.SQLWCHAR + SQLSCHAR C.SQLSCHAR + SQLSMALLINT C.SQLSMALLINT + SQLUSMALLINT C.SQLUSMALLINT + SQLINTEGER C.SQLINTEGER + SQLUINTEGER C.SQLUINTEGER + SQLPOINTER C.SQLPOINTER + SQLRETURN C.SQLRETURN + + SQLLEN C.SQLLEN + SQLULEN C.SQLULEN +) + +func SQLSetEnvUIntPtrAttr(environmentHandle SQLHENV, attribute SQLINTEGER, valuePtr uintptr, stringLength SQLINTEGER) (ret SQLRETURN) { + trc.Trace1("api/api_unix.go SQLSetEnvUIntPtrAttr() - ENTRY") + trc.Trace1(fmt.Sprintf("attribute=%d, valuePtr=0x%x, stringLength=%d", attribute, valuePtr, stringLength)) + + r := C.sqlSetEnvUIntPtrAttr(C.SQLHENV(environmentHandle), C.SQLINTEGER(attribute), C.uintptr_t(valuePtr), C.SQLINTEGER(stringLength)) + + trc.Trace1(fmt.Sprintf("r = %d", r)) + trc.Trace1("api/api_unix.go SQLSetEnvUIntPtrAttr() - EXIT") + return SQLRETURN(r) +} + +func SQLSetConnectUIntPtrAttr(connectionHandle SQLHDBC, attribute SQLINTEGER, valuePtr uintptr, stringLength SQLINTEGER) (ret SQLRETURN) { + trc.Trace1("api/api_unix.go SQLSetConnectUIntPtrAttr() - ENTRY") + trc.Trace1(fmt.Sprintf("attribute=%d, valuePtr=%x, stringLength=%d", attribute, valuePtr, stringLength)) + + r := C.sqlSetConnectUIntPtrAttr(C.SQLHDBC(connectionHandle), C.SQLINTEGER(attribute), C.uintptr_t(valuePtr), C.SQLINTEGER(stringLength)) + + trc.Trace1(fmt.Sprintf("r = %d", r)) + trc.Trace1("api/api_unix.go SQLSetConnectUIntPtrAttr() - EXIT") + return SQLRETURN(r) +} diff --git a/vendor/github.com/ibmdb/go_ibm_db/api/api_windows.go b/vendor/github.com/ibmdb/go_ibm_db/api/api_windows.go new file mode 100644 index 00000000..fc21602b --- /dev/null +++ b/vendor/github.com/ibmdb/go_ibm_db/api/api_windows.go @@ -0,0 +1,229 @@ +// Copyright 2012 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package api + +import ( + "syscall" + trc "github.com/ibmdb/go_ibm_db/log2" + "fmt" +) + +const ( + SQL_OV_ODBC3 = 3 + + SQL_ATTR_ODBC_VERSION = 200 + + SQL_DRIVER_NOPROMPT = 0 + + SQL_HANDLE_ENV = 1 + SQL_HANDLE_DBC = 2 + SQL_HANDLE_STMT = 3 + + SQL_SUCCESS = 0 + SQL_SUCCESS_WITH_INFO = 1 + SQL_INVALID_HANDLE = -2 + SQL_NO_DATA = 100 + SQL_NO_TOTAL = -4 + SQL_NTS = -3 + SQL_MAX_MESSAGE_LENGTH = 512 + SQL_NULL_HANDLE = 0 + SQL_NULL_HENV = 0 + SQL_NULL_HDBC = 0 + SQL_NULL_HSTMT = 0 + + SQL_PARAM_INPUT = 1 + SQL_PARAM_INPUT_OUTPUT = 2 + SQL_PARAM_OUTPUT = 4 + + SQL_NULL_DATA = -1 + SQL_DATA_AT_EXEC = -2 + + SQL_UNKNOWN_TYPE = 0 + SQL_CHAR = 1 + SQL_NUMERIC = 2 + SQL_DECIMAL = 3 + SQL_INTEGER = 4 + SQL_SMALLINT = 5 + SQL_FLOAT = 6 + SQL_REAL = 7 + SQL_DOUBLE = 8 + SQL_DATETIME = 9 + SQL_DATE = 9 + SQL_TIME = 10 + SQL_VARCHAR = 12 + SQL_TYPE_DATE = 91 + SQL_TYPE_TIME = 92 + SQL_TYPE_TIMESTAMP = 93 + SQL_NEED_DATA = 99 + SQL_TIMESTAMP = 11 + SQL_LONGVARCHAR = -1 + SQL_BINARY = -2 + SQL_VARBINARY = -3 + SQL_LONGVARBINARY = -4 + SQL_BIGINT = -5 + SQL_TINYINT = -6 + SQL_BIT = -7 + SQL_WCHAR = -8 + SQL_WVARCHAR = -9 + SQL_WLONGVARCHAR = -10 + SQL_GUID = -11 + SQL_SIGNED_OFFSET = -20 + SQL_UNSIGNED_OFFSET = -22 + SQL_GRAPHIC = -95 + SQL_BLOB = -98 + SQL_CLOB = -99 + SQL_DBCLOB = -350 + SQL_SS_XML = -152 + SQL_BOOLEAN = 16 + SQL_DECFLOAT = -360 + SQL_XML = -370 + + SQL_C_CHAR = SQL_CHAR + SQL_C_LONG = SQL_INTEGER + SQL_C_SHORT = SQL_SMALLINT + SQL_C_FLOAT = SQL_REAL + SQL_C_DOUBLE = SQL_DOUBLE + SQL_C_NUMERIC = SQL_NUMERIC + SQL_C_DATE = SQL_DATE + SQL_C_TIME = SQL_TIME + SQL_C_TYPE_TIMESTAMP = SQL_TYPE_TIMESTAMP + SQL_C_TIMESTAMP = SQL_TIMESTAMP + SQL_C_BINARY = SQL_BINARY + SQL_C_BIT = SQL_BIT + SQL_C_WCHAR = SQL_WCHAR + SQL_C_DBCHAR = SQL_DBCLOB + SQL_C_DEFAULT = 99 + SQL_C_SBIGINT = SQL_BIGINT + SQL_SIGNED_OFFSET + SQL_C_UBIGINT = SQL_BIGINT + SQL_UNSIGNED_OFFSET + SQL_C_GUID = SQL_GUID + SQL_C_TYPE_DATE = SQL_TYPE_DATE + SQL_C_TYPE_TIME = SQL_TYPE_TIME + SQL_C_DECFLOAT = SQL_DECFLOAT + SQL_C_XML = SQL_XML + + SQL_COMMIT = 0 + SQL_ROLLBACK = 1 + + SQL_AUTOCOMMIT = 102 + SQL_ATTR_AUTOCOMMIT = SQL_AUTOCOMMIT + SQL_AUTOCOMMIT_OFF = 0 + SQL_AUTOCOMMIT_ON = 1 + SQL_AUTOCOMMIT_DEFAULT = SQL_AUTOCOMMIT_ON + SQL_ATTR_PARAMSET_SIZE = 22 + // Statement attributes + SQL_ROW_NUMBER = 14 + + // Statement attributes for ODBC 3.0 + SQL_ATTR_CURSOR_TYPE = 6 + //SQL_ATTR_PARAMSET_SIZE = 22 + SQL_ATTR_ROW_NUMBER = SQL_ROW_NUMBER + SQL_ATTR_ROW_ARRAY_SIZE = 27 + SQL_ATTR_ROW_STATUS_PTR = 25 + SQL_ATTR_ROWS_FETCHED_PTR = 26 + + // SQL_CURSOR_TYPE options + SQL_CURSOR_FORWARD_ONLY = 0 + SQL_CURSOR_KEYSET_DRIVEN = 1 + SQL_CURSOR_DYNAMIC = 2 + SQL_CURSOR_STATIC = 3 + SQL_CURSOR_TYPE_DEFAULT = SQL_CURSOR_FORWARD_ONLY + + // Operations in SQLSetPos + SQL_POSITION = 0 + SQL_REFRESH = 1 + SQL_UPDATE = 2 + SQL_DELETE = 3 + + // Operations in SQLBulkOperations + SQL_ADD = 4 + SQL_SETPOS_MAX_OPTION_VALUE = SQL_ADD + SQL_UPDATE_BY_BOOKMARK = 5 // Check if to be removed + SQL_DELETE_BY_BOOKMARK = 6 + SQL_FETCH_BY_BOOKMARK = 7 + + // Lock options in SQLSetPos + SQL_LOCK_NO_CHANGE = 0 + + SQL_IS_UINTEGER = -5 + SQL_IS_INTEGER = -6 + + // Fetch Orientation in SQLFetchScroll + SQL_FETCH_NEXT = 1 + SQL_FETCH_FIRST = 2 + SQL_FETCH_LAST = 3 + SQL_FETCH_PRIOR = 4 + SQL_FETCH_ABSOLUTE = 5 + SQL_FETCH_RELATIVE = 6 + + //Connection pooling + SQL_ATTR_CONNECTION_POOLING = 201 + SQL_ATTR_CP_MATCH = 202 + SQL_CP_OFF = 0 + SQL_CP_ONE_PER_DRIVER = 1 + SQL_CP_ONE_PER_HENV = 2 + SQL_CP_DEFAULT = SQL_CP_OFF + SQL_CP_STRICT_MATCH = 0 + SQL_CP_RELAXED_MATCH = 1 + SQL_DESC_PRECISION = 1005 + SQL_DESC_SCALE = 1006 + SQL_DESC_LENGTH = 1003 + SQL_DESC_CONCISE_TYPE = SQL_COLUMN_TYPE + SQL_DESC_TYPE_NAME = SQL_COLUMN_TYPE_NAME + SQL_COLUMN_TYPE = 2 + SQL_COLUMN_TYPE_NAME = 14 + MAX_FIELD_SIZE = 1024 + SQL_DESC_NULLABLE = 1008 + SQL_NULLABLE = 1 + SQL_NO_NULLS = 0 +) + +type ( + SQLHANDLE uintptr + SQLHENV SQLHANDLE + SQLHDBC SQLHANDLE + SQLHSTMT SQLHANDLE + SQLHWND uintptr + + SQLWCHAR uint16 + SQLSCHAR int8 + SQLSMALLINT int16 + SQLUSMALLINT uint16 + SQLINTEGER int32 + SQLUINTEGER uint32 + SQLPOINTER uintptr + SQLRETURN SQLSMALLINT + SQLSETPOSIROW SQLUSMALLINT + + SQLGUID struct { + Data1 uint32 + Data2 uint16 + Data3 uint16 + Data4 [8]byte + } +) + +func SQLSetEnvUIntPtrAttr(environmentHandle SQLHENV, attribute SQLINTEGER, valuePtr uintptr, stringLength SQLINTEGER) (ret SQLRETURN) { + trc.Trace1("api/api_windows.go SQLSetEnvUIntPtrAttr() - ENTRY") + trc.Trace1(fmt.Sprintf("attribute=%d, valuePtr=0x%x, stringLength=%d", attribute, valuePtr, stringLength)) + + r0, _, _ := syscall.Syscall6(procSQLSetEnvAttr.Addr(), 4, uintptr(environmentHandle), uintptr(attribute), uintptr(valuePtr), uintptr(stringLength), 0, 0) + ret = SQLRETURN(r0) + + trc.Trace1(fmt.Sprintf("ret = %d", ret)) + trc.Trace1("api/api_windows.go SQLSetEnvUIntPtrAttr() - EXIT") + return +} + +func SQLSetConnectUIntPtrAttr(connectionHandle SQLHDBC, attribute SQLINTEGER, valuePtr uintptr, stringLength SQLINTEGER) (ret SQLRETURN) { + trc.Trace1("api/api_windows.go SQLSetConnectUIntPtrAttr() - ENTRY") + trc.Trace1(fmt.Sprintf("attribute=%d, valuePtr=%x, stringLength=%d", attribute, valuePtr, stringLength)) + + r0, _, _ := syscall.Syscall6(procSQLSetConnectAttrW.Addr(), 4, uintptr(connectionHandle), uintptr(attribute), uintptr(valuePtr), uintptr(stringLength), 0, 0) + ret = SQLRETURN(r0) + + trc.Trace1(fmt.Sprintf("ret = %d", ret)) + trc.Trace1("api/api_windows.go SQLSetConnectUIntPtrAttr() - EXIT") + return +} diff --git a/vendor/github.com/ibmdb/go_ibm_db/api/api_windows_386.go b/vendor/github.com/ibmdb/go_ibm_db/api/api_windows_386.go new file mode 100644 index 00000000..2edf92a3 --- /dev/null +++ b/vendor/github.com/ibmdb/go_ibm_db/api/api_windows_386.go @@ -0,0 +1,10 @@ +// Copyright 2012 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package api + +type ( + SQLLEN SQLINTEGER + SQLULEN SQLUINTEGER +) diff --git a/vendor/github.com/ibmdb/go_ibm_db/api/api_windows_amd64.go b/vendor/github.com/ibmdb/go_ibm_db/api/api_windows_amd64.go new file mode 100644 index 00000000..b6036637 --- /dev/null +++ b/vendor/github.com/ibmdb/go_ibm_db/api/api_windows_amd64.go @@ -0,0 +1,10 @@ +// Copyright 2012 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package api + +type ( + SQLLEN int64 + SQLULEN uint64 +) diff --git a/vendor/github.com/ibmdb/go_ibm_db/api/api_zos.go b/vendor/github.com/ibmdb/go_ibm_db/api/api_zos.go new file mode 100644 index 00000000..571439e6 --- /dev/null +++ b/vendor/github.com/ibmdb/go_ibm_db/api/api_zos.go @@ -0,0 +1,185 @@ +// Copyright 2024 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +//go:build zos + +package api + +import ( + "log" + "runtime" + "unsafe" + "github.com/ibmruntimes/go-recordio/v2/utils" + trc "github.com/ibmdb/go_ibm_db/log2" + "fmt" +) + +func getFunc(dll *utils.Dll, str string) uintptr { + fp, e := dll.Sym(str) + if e != nil { + pc, fn, line, _ := runtime.Caller(1) + log.Fatalf("[FATAL] %s [%s:%s:%d]", e, runtime.FuncForPC(pc).Name(), fn, line) + } + return fp +} + +const ( + SQL_MAX_OPTION_STRING_LENGTH = 256 + SQL_OV_ODBC3 = 3 + SQL_ATTR_ODBC_VERSION = 200 + SQL_DRIVER_NOPROMPT = 0 + SQL_HANDLE_ENV = 1 + SQL_HANDLE_DBC = 2 + SQL_HANDLE_STMT = 3 + SQL_SUCCESS = 0 + SQL_SUCCESS_WITH_INFO = 1 + SQL_INVALID_HANDLE = -2 + SQL_NO_DATA = 100 + SQL_NO_TOTAL = -4 + SQL_NTS = -3 + SQL_MAX_MESSAGE_LENGTH = 1024 + SQL_NULL_HANDLE = 0 + SQL_NULL_HENV = 0 + SQL_NULL_HDBC = 0 + SQL_NULL_HSTMT = 0 + SQL_PARAM_INPUT = 1 + SQL_PARAM_OUTPUT = 4 + SQL_PARAM_INPUT_OUTPUT = 2 + SQL_NULL_DATA = -1 + SQL_DATA_AT_EXEC = -2 + SQL_CHAR = 1 + SQL_NUMERIC = 2 + SQL_DECIMAL = 3 + SQL_INTEGER = 4 + SQL_SMALLINT = 5 + SQL_FLOAT = 6 + SQL_REAL = 7 + SQL_DOUBLE = 8 + SQL_DATETIME = 9 + SQL_DATE = 9 + SQL_TIME = 10 + SQL_VARCHAR = 12 + SQL_TYPE_DATE = 91 + SQL_TYPE_TIME = 92 + SQL_TYPE_TIMESTAMP = 93 + SQL_TIMESTAMP = 11 + SQL_LONGVARCHAR = -1 + SQL_BINARY = -2 + SQL_VARBINARY = -3 + SQL_LONGVARBINARY = -4 + SQL_BIGINT = -5 + SQL_TINYINT = -6 + SQL_BIT = -7 + SQL_WCHAR = -8 + SQL_WVARCHAR = -9 + SQL_WLONGVARCHAR = -10 + SQL_BLOB = -98 + SQL_CLOB = -99 + SQL_SIGNED_OFFSET = -20 + SQL_UNSIGNED_OFFSET = -22 + SQL_DBCLOB = -350 + SQL_XML = -370 + SQL_COMMIT = 0 + SQL_ROLLBACK = 1 + SQL_AUTOCOMMIT = 102 + SQL_ATTR_AUTOCOMMIT = 102 + SQL_AUTOCOMMIT_OFF = 0 + SQL_AUTOCOMMIT_ON = 1 + SQL_AUTOCOMMIT_DEFAULT = 1 + SQL_DESC_PRECISION = 1005 + SQL_DESC_SCALE = 1006 + SQL_DESC_LENGTH = 1003 + SQL_DESC_CONCISE_TYPE = 2 + SQL_DESC_TYPE_NAME = 14 + SQL_COLUMN_TYPE = 2 + SQL_COLUMN_TYPE_NAME = 14 + SQL_DESC_NULLABLE = 1008 + SQL_NULLABLE = 1 + SQL_NO_NULLS = 0 + SQL_DECFLOAT = -360 + SQL_ATTR_PARAMSET_SIZE = 22 + SQL_IS_UINTEGER = -5 + SQL_IS_INTEGER = -6 + SQL_ATTR_CONNECTION_POOLING = 201 + SQL_ATTR_CP_MATCH = 202 + SQL_CP_OFF = 0 + SQL_CP_ONE_PER_DRIVER = 1 + SQL_CP_ONE_PER_HENV = 2 + SQL_CP_DEFAULT = 0 + SQL_CP_STRICT_MATCH = 0 + SQL_CP_RELAXED_MATCH = 1 + SQL_C_CHAR = 1 + SQL_C_LONG = 4 + SQL_C_SHORT = 5 + SQL_C_FLOAT = 7 + SQL_C_DOUBLE = 8 + SQL_C_NUMERIC = 2 + SQL_C_DATE = 9 + SQL_C_TIME = 10 + SQL_C_TYPE_TIMESTAMP = 93 + SQL_C_TIMESTAMP = 11 + SQL_C_BINARY = -2 + SQL_C_BIT = -7 + SQL_C_WCHAR = -8 + SQL_C_DEFAULT = 99 + SQL_C_SBIGINT = -25 + SQL_C_UBIGINT = -27 + SQL_C_DBCHAR = -350 + SQL_C_TYPE_DATE = 91 + SQL_C_TYPE_TIME = 92 + + // TODO(hyder): Not defined in sqlext.h. Using windows value, but it is not supported. + SQL_SS_XML = -152 + + MAX_FIELD_SIZE = 1024 + SQL_BOOLEAN = 16 +) + +type ( + SQLCHAR byte + SQLSCHAR byte + SQLINTEGER int32 + SDWORD int32 + SQLSMALLINT int16 + SQLDOUBLE float64 + SQLREAL float32 + SQLBIGINT int64 + ODBCINT64 int64 + SQLRETURN int16 + UDWORD uint32 + SQLUINTEGER uint32 + SQLUSMALLINT uint16 + SQLSETPOSIROW uint16 + UWORD uint16 + SQLPOINTER unsafe.Pointer + SQLLEN SQLINTEGER + SQLULEN SQLUINTEGER + SQLDBCHAR uint16 + SQLWCHAR uint16 + SQLHANDLE SQLINTEGER + SQLHENV SQLINTEGER + SQLHDBC SQLINTEGER + SQLHSTMT SQLINTEGER + SQLHWND uintptr +) + +func SQLSetEnvUIntPtrAttr(environmentHandle SQLHENV, attribute SQLINTEGER, valuePtr uintptr, stringLength SQLINTEGER) (ret SQLRETURN) { + trc.Trace1("api/api_zos.go SQLSetEnvUIntPtrAttr() - ENTRY") + + r := utils.CfuncEbcdic(getFunc(&dll, "SQLSetEnvAttr"), uintptr(environmentHandle), uintptr(attribute), uintptr(valuePtr), uintptr(stringLength)) + + trc.Trace1(fmt.Sprintf("r = %d", r)) + trc.Trace1("api/api_zos.go SQLSetEnvUIntPtrAttr() - EXIT") + return SQLRETURN(r) +} + +func SQLSetConnectUIntPtrAttr(connectionHandle SQLHDBC, attribute SQLINTEGER, valuePtr uintptr, stringLength SQLINTEGER) (ret SQLRETURN) { + trc.Trace1("api/api_zos.go SQLSetConnectUIntPtrAttr() - ENTRY") + + r := utils.CfuncEbcdic(getFunc(&dll, "SQLSetConnectAttr"), uintptr(connectionHandle), uintptr(attribute), uintptr(valuePtr), uintptr(stringLength)) + + trc.Trace1(fmt.Sprintf("r = %d", r)) + trc.Trace1("api/api_zos.go SQLSetConnectUIntPtrAttr() - EXIT") + return SQLRETURN(r) +} diff --git a/vendor/github.com/ibmdb/go_ibm_db/api/mksyscall_unix.pl b/vendor/github.com/ibmdb/go_ibm_db/api/mksyscall_unix.pl new file mode 100644 index 00000000..eb6ecf59 --- /dev/null +++ b/vendor/github.com/ibmdb/go_ibm_db/api/mksyscall_unix.pl @@ -0,0 +1,132 @@ +#!/usr/bin/perl +# Copyright 2012 The Go Authors. All rights reserved. +# Use of this source code is governed by a BSD-style +# license that can be found in the LICENSE file. + +# This program is based on $GOROOT/src/pkg/syscall/mksyscall_windows.pl. + +use strict; + +my $cmdline = "mksyscall_unix.pl " . join(' ', @ARGV); +my $errors = 0; + +binmode STDOUT; + +if($ARGV[0] =~ /^-/) { + print STDERR "usage: mksyscall_unix.pl [file ...]\n"; + exit 1; +} + +sub parseparamlist($) { + my ($list) = @_; + $list =~ s/^\s*//; + $list =~ s/\s*$//; + if($list eq "") { + return (); + } + return split(/\s*,\s*/, $list); +} + +sub parseparam($) { + my ($p) = @_; + if($p !~ /^(\S*) (\S*)$/) { + print STDERR "$ARGV:$.: malformed parameter: $p\n"; + $errors = 1; + return ("xx", "int"); + } + return ($1, $2); +} + +my $package = ""; +my $text = ""; +while(<>) { + chomp; + s/\s+/ /g; + s/^\s+//; + s/\s+$//; + $package = $1 if !$package && /^package (\S+)$/; + next if !/^\/\/sys /; + + # Line must be of the form + # func Open(path string, mode int, perm int) (fd int, err error) + # Split into name, in params, out params. + if(!/^\/\/sys (\w+)\(([^()]*)\)\s*(?:\(([^()]+)\))?\s*(?:\[failretval(.*)\])?\s*(?:=\s*(?:(\w*)\.)?(\w*))?$/) { + print STDERR "$ARGV:$.: malformed //sys declaration\n"; + $errors = 1; + next; + } + my ($func, $in, $out, $failcond, $modname, $sysname) = ($1, $2, $3, $4, $5, $6); + + # Split argument lists on comma. + my @in = parseparamlist($in); + my @out = parseparamlist($out); + + # System call name. + if($sysname eq "") { + $sysname = "$func"; + } + + # Go function header. + $out = join(', ', @out); + if($out ne "") { + $out = " ($out)"; + } + if($text ne "") { + $text .= "\n" + } + $text .= sprintf "func %s(%s)%s {\n", $func, join(', ', @in), $out; + + # Prepare arguments. + my @sqlin= (); + my @pin= (); + foreach my $p (@in) { + my ($name, $type) = parseparam($p); + + if($type =~ /^\*(SQLCHAR)/) { + push @sqlin, sprintf "(*C.%s)(unsafe.Pointer(%s))", $1, $name; + } elsif($type =~ /^\*(SQLWCHAR)/) { + push @sqlin, sprintf "(*C.%s)(unsafe.Pointer(%s))", $1, $name; + } elsif($type =~ /^\*(.*)$/) { + push @sqlin, sprintf "(*C.%s)(%s)", $1, $name; + } else { + push @sqlin, sprintf "C.%s(%s)", $type, $name; + } + push @pin, sprintf "\"%s=\", %s, ", $name, $name; + } + + $text .= sprintf "\tr := C.%s(%s)\n", $sysname, join(',', @sqlin); + if(0) { + $text .= sprintf "println(\"SYSCALL: %s(\", %s\") (\", r, \")\")\n", $func, join('", ", ', @pin); + } + $text .= "\treturn SQLRETURN(r)\n"; + $text .= "}\n"; +} + +if($errors) { + exit 1; +} + +print < +import "C" + +$text + +EOF +exit 0; diff --git a/vendor/github.com/ibmdb/go_ibm_db/api/zapi_unix.go b/vendor/github.com/ibmdb/go_ibm_db/api/zapi_unix.go new file mode 100644 index 00000000..982bc467 --- /dev/null +++ b/vendor/github.com/ibmdb/go_ibm_db/api/zapi_unix.go @@ -0,0 +1,302 @@ +// mksyscall_unix.pl api.go +// MACHINE GENERATED BY THE COMMAND ABOVE; DO NOT EDIT + +// Copyright 2012 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// +build aix darwin linux +// +build cgo + +package api + +import ( + "fmt" + "unsafe" + trc "github.com/ibmdb/go_ibm_db/log2" +) + +// #cgo aix LDFLAGS: -ldb2 +// #cgo darwin LDFLAGS: -ldb2 +// #cgo linux LDFLAGS: -ldb2 +// #include +import "C" + +func SQLAllocHandle(handleType SQLSMALLINT, inputHandle SQLHANDLE, outputHandle *SQLHANDLE) (ret SQLRETURN) { + trc.Trace1("api/zapi_unix.go SQLAllocHandle() - ENTRY") + trc.Trace1(fmt.Sprintf("handleType=%d", handleType)) + + r := C.SQLAllocHandle(C.SQLSMALLINT(handleType), C.SQLHANDLE(inputHandle), (*C.SQLHANDLE)(outputHandle)) + + trc.Trace1(fmt.Sprintf("r = %d", r)) + trc.Trace1("api/zapi_unix.go SQLAllocHandle() - EXIT") + return SQLRETURN(r) +} + +func SQLBindCol(statementHandle SQLHSTMT, columnNumber SQLUSMALLINT, targetType SQLSMALLINT, targetValuePtr []byte, bufferLength SQLLEN, vallen *SQLLEN) (ret SQLRETURN) { + trc.Trace1("api/zapi_unix.go SQLBindCol() - ENTRY") + trc.Trace1(fmt.Sprintf("columnNumber=%d, targetType=%d, bufferLength=%d", columnNumber, targetType, bufferLength)) + + r := C.SQLBindCol(C.SQLHSTMT(statementHandle), C.SQLUSMALLINT(columnNumber), C.SQLSMALLINT(targetType), C.SQLPOINTER(&targetValuePtr[0]), C.SQLLEN(bufferLength), (*C.SQLLEN)(vallen)) + + trc.Trace1(fmt.Sprintf("r = %d", r)) + trc.Trace1("api/zapi_unix.go SQLBindCol() - EXIT") + return SQLRETURN(r) +} + +func SQLBindParameter(statementHandle SQLHSTMT, parameterNumber SQLUSMALLINT, inputOutputType SQLSMALLINT, valueType SQLSMALLINT, parameterType SQLSMALLINT, columnSize SQLULEN, decimalDigits SQLSMALLINT, parameterValue SQLPOINTER, bufferLength SQLLEN, ind *SQLLEN) (ret SQLRETURN) { + trc.Trace1("api/zapi_unix.go SQLBindParameter() - ENTRY") + trc.Trace1(fmt.Sprintf("parameterNumber=%d, inputOutputType=%d, valueType=%d, parameterType=%d, columnSize=%d, decimalDigits=%d, parameterValue=%x, bufferLength=%d", parameterNumber, inputOutputType, valueType, parameterType, columnSize, decimalDigits, parameterValue, bufferLength)) + + r := C.SQLBindParameter(C.SQLHSTMT(statementHandle), C.SQLUSMALLINT(parameterNumber), C.SQLSMALLINT(inputOutputType), C.SQLSMALLINT(valueType), C.SQLSMALLINT(parameterType), C.SQLULEN(columnSize), C.SQLSMALLINT(decimalDigits), C.SQLPOINTER(parameterValue), C.SQLLEN(bufferLength), (*C.SQLLEN)(ind)) + + trc.Trace1(fmt.Sprintf("r = %d", r)) + trc.Trace1("api/zapi_unix.go SQLBindParameter() - EXIT") + return SQLRETURN(r) +} + +func SQLCloseCursor(statementHandle SQLHSTMT) (ret SQLRETURN) { + trc.Trace1("api/zapi_unix.go SQLCloseCursor() - ENTRY") + + r := C.SQLCloseCursor(C.SQLHSTMT(statementHandle)) + + trc.Trace1(fmt.Sprintf("r = %d", r)) + trc.Trace1("api/zapi_unix.go SQLCloseCursor() - EXIT") + return SQLRETURN(r) +} + +func SQLDescribeCol(statementHandle SQLHSTMT, columnNumber SQLUSMALLINT, columnName *SQLWCHAR, bufferLength SQLSMALLINT, nameLengthPtr *SQLSMALLINT, dataTypePtr *SQLSMALLINT, columnSizePtr *SQLULEN, decimalDigitsPtr *SQLSMALLINT, nullablePtr *SQLSMALLINT) (ret SQLRETURN) { + trc.Trace1("api/zapi_unix.go SQLDescribeCol() - ENTRY") + trc.Trace1(fmt.Sprintf("columnNumber=%d, columnName=%s, bufferLength=%d, nameLengthPtr=0x%x, dataTypePtr=0x%x, columnSizePtr=0x%x, decimalDigitsPtr=%x, nullablePtr=0x%x", columnNumber, *columnName, bufferLength, nameLengthPtr, dataTypePtr, columnSizePtr, decimalDigitsPtr, nullablePtr)) + + r := C.SQLDescribeColW(C.SQLHSTMT(statementHandle), C.SQLUSMALLINT(columnNumber), (*C.SQLWCHAR)(unsafe.Pointer(columnName)), C.SQLSMALLINT(bufferLength), (*C.SQLSMALLINT)(nameLengthPtr), (*C.SQLSMALLINT)(dataTypePtr), (*C.SQLULEN)(columnSizePtr), (*C.SQLSMALLINT)(decimalDigitsPtr), (*C.SQLSMALLINT)(nullablePtr)) + + trc.Trace1(fmt.Sprintf("r = %d", r)) + trc.Trace1("api/zapi_unix.go SQLDescribeCol() - EXIT") + return SQLRETURN(r) +} + +func SQLDescribeParam(statementHandle SQLHSTMT, parameterNumber SQLUSMALLINT, dataTypePtr *SQLSMALLINT, parameterSizePtr *SQLULEN, decimalDigitsPtr *SQLSMALLINT, nullablePtr *SQLSMALLINT) (ret SQLRETURN) { + trc.Trace1("api/zapi_unix.go SQLDescribeParam() - ENTRY") + trc.Trace1(fmt.Sprintf("parameterNumber=%d, dataTypePtr=%x, parameterSizePtr=%x, decimalDigitsPtr=%x, nullablePtr=%x", parameterNumber, dataTypePtr, parameterSizePtr, decimalDigitsPtr, nullablePtr)) + + r := C.SQLDescribeParam(C.SQLHSTMT(statementHandle), C.SQLUSMALLINT(parameterNumber), (*C.SQLSMALLINT)(dataTypePtr), (*C.SQLULEN)(parameterSizePtr), (*C.SQLSMALLINT)(decimalDigitsPtr), (*C.SQLSMALLINT)(nullablePtr)) + + trc.Trace1(fmt.Sprintf("r = %d", r)) + trc.Trace1("api/zapi_unix.go SQLDescribeParam() - EXIT") + return SQLRETURN(r) +} + +func SQLDisconnect(connectionHandle SQLHDBC) (ret SQLRETURN) { + trc.Trace1("api/zapi_unix.go SQLDisconnect() - ENTRY") + + r := C.SQLDisconnect(C.SQLHDBC(connectionHandle)) + + trc.Trace1(fmt.Sprintf("r = %d", r)) + trc.Trace1("api/zapi_unix.go SQLDisconnect() - EXIT") + return SQLRETURN(r) +} + +func SQLDriverConnect(connectionHandle SQLHDBC, windowHandle SQLHWND, inConnectionString *SQLWCHAR, stringLength1 SQLSMALLINT, outConnectionString *SQLWCHAR, bufferLength SQLSMALLINT, stringLength2Ptr *SQLSMALLINT, driverCompletion SQLUSMALLINT) (ret SQLRETURN) { + trc.Trace1("api/zapi_unix.go SQLDriverConnect() - ENTRY") + trc.Trace1(fmt.Sprintf("inConnectionString=%s, stringLength1=%d, outConnectionString=%s, bufferLength=%d, stringLength2Ptr=%x, driverCompletion=%d", inConnectionString, stringLength1, outConnectionString, bufferLength, stringLength2Ptr, driverCompletion)) + + r := C.SQLDriverConnectW(C.SQLHDBC(connectionHandle), C.SQLHWND(windowHandle), (*C.SQLWCHAR)(unsafe.Pointer(inConnectionString)), C.SQLSMALLINT(stringLength1), (*C.SQLWCHAR)(unsafe.Pointer(outConnectionString)), C.SQLSMALLINT(bufferLength), (*C.SQLSMALLINT)(stringLength2Ptr), C.SQLUSMALLINT(driverCompletion)) + + trc.Trace1(fmt.Sprintf("r = %d", r)) + trc.Trace1("api/zapi_unix.go SQLDriverConnect() - EXIT") + return SQLRETURN(r) +} + +func SQLEndTran(handleType SQLSMALLINT, handle SQLHANDLE, completionType SQLSMALLINT) (ret SQLRETURN) { + trc.Trace1("api/zapi_unix.go SQLEndTran() - ENTRY") + trc.Trace1(fmt.Sprintf("handleType=%d, completionType=%d", handleType, completionType)) + + r := C.SQLEndTran(C.SQLSMALLINT(handleType), C.SQLHANDLE(handle), C.SQLSMALLINT(completionType)) + + trc.Trace1(fmt.Sprintf("r = %d", r)) + trc.Trace1("api/zapi_unix.go SQLEndTran() - EXIT") + return SQLRETURN(r) +} + +func SQLExecute(statementHandle SQLHSTMT) (ret SQLRETURN) { + trc.Trace1("api/zapi_unix.go SQLExecute() - ENTRY") + + r := C.SQLExecute(C.SQLHSTMT(statementHandle)) + + trc.Trace1(fmt.Sprintf("r = %d", r)) + trc.Trace1("api/zapi_unix.go SQLExecute() - EXIT") + return SQLRETURN(r) +} + +func SQLFetch(statementHandle SQLHSTMT) (ret SQLRETURN) { + trc.Trace1("api/zapi_unix.go SQLFetch() - ENTRY") + + r := C.SQLFetch(C.SQLHSTMT(statementHandle)) + + trc.Trace1(fmt.Sprintf("r = %d", r)) + trc.Trace1("api/zapi_unix.go SQLFetch() - EXIT") + return SQLRETURN(r) +} + +func SQLFreeHandle(handleType SQLSMALLINT, handle SQLHANDLE) (ret SQLRETURN) { + trc.Trace1("api/zapi_unix.go SQLFreeHandle() - ENTRY") + trc.Trace1(fmt.Sprintf("handleType=%d", handleType)) + + r := C.SQLFreeHandle(C.SQLSMALLINT(handleType), C.SQLHANDLE(handle)) + + trc.Trace1(fmt.Sprintf("r = %d", r)) + trc.Trace1("api/zapi_unix.go SQLFreeHandle() - EXIT") + return SQLRETURN(r) +} + +func SQLGetData(statementHandle SQLHSTMT, colOrParamNum SQLUSMALLINT, targetType SQLSMALLINT, targetValuePtr SQLPOINTER, bufferLength SQLLEN, vallen *SQLLEN) (ret SQLRETURN) { + trc.Trace1("api/zapi_unix.go SQLGetData() - ENTRY") + trc.Trace1(fmt.Sprintf("colOrParamNum=%d, targetType=%d, targetValuePtr=%x, bufferLength=%d, vallen=%d", colOrParamNum, targetType, targetValuePtr, bufferLength, vallen)) + + r := C.SQLGetData(C.SQLHSTMT(statementHandle), C.SQLUSMALLINT(colOrParamNum), C.SQLSMALLINT(targetType), C.SQLPOINTER(targetValuePtr), C.SQLLEN(bufferLength), (*C.SQLLEN)(vallen)) + + trc.Trace1(fmt.Sprintf("r = %d", r)) + trc.Trace1("api/zapi_unix.go SQLGetData() - EXIT") + return SQLRETURN(r) +} + +func SQLGetDiagRec(handleType SQLSMALLINT, handle SQLHANDLE, recNumber SQLSMALLINT, sqlState *SQLWCHAR, nativeErrorPtr *SQLINTEGER, messageText *SQLWCHAR, bufferLength SQLSMALLINT, textLengthPtr *SQLSMALLINT) (ret SQLRETURN) { + trc.Trace1("api/zapi_unix.go SQLGetDiagRec() - ENTRY") + trc.Trace1(fmt.Sprintf("handleType=%d, recNumber=%d, sqlState=%s, nativeErrorPtr=%x, messageText=%s, bufferLength=%d, textLengthPtr=%x", handleType, recNumber, sqlState, nativeErrorPtr, messageText, bufferLength, textLengthPtr)) + + r := C.SQLGetDiagRecW(C.SQLSMALLINT(handleType), C.SQLHANDLE(handle), C.SQLSMALLINT(recNumber), (*C.SQLWCHAR)(unsafe.Pointer(sqlState)), (*C.SQLINTEGER)(nativeErrorPtr), (*C.SQLWCHAR)(unsafe.Pointer(messageText)), C.SQLSMALLINT(bufferLength), (*C.SQLSMALLINT)(textLengthPtr)) + + trc.Trace1(fmt.Sprintf("r = %d", r)) + trc.Trace1("api/zapi_unix.go SQLGetDiagRec() - EXIT") + return SQLRETURN(r) +} + +func SQLNumParams(statementHandle SQLHSTMT, parameterCountPtr *SQLSMALLINT) (ret SQLRETURN) { + trc.Trace1("api/zapi_unix.go SQLNumParams() - ENTRY") + trc.Trace1(fmt.Sprintf("parameterCountPtr=0x%x", parameterCountPtr)) + + r := C.SQLNumParams(C.SQLHSTMT(statementHandle), (*C.SQLSMALLINT)(parameterCountPtr)) + + trc.Trace1(fmt.Sprintf("r = %d", r)) + trc.Trace1("api/zapi_unix.go SQLNumParams() - EXIT") + return SQLRETURN(r) +} + +func SQLNumResultCols(statementHandle SQLHSTMT, columnCountPtr *SQLSMALLINT) (ret SQLRETURN) { + trc.Trace1("api/zapi_unix.go SQLNumResultCols() - ENTRY") + trc.Trace1(fmt.Sprintf("columnCountPtr=%x", columnCountPtr)) + + r := C.SQLNumResultCols(C.SQLHSTMT(statementHandle), (*C.SQLSMALLINT)(columnCountPtr)) + + trc.Trace1(fmt.Sprintf("r = %d", r)) + trc.Trace1("api/zapi_unix.go SQLNumResultCols() - EXIT") + return SQLRETURN(r) +} + +func SQLPrepare(statementHandle SQLHSTMT, statementText *SQLWCHAR, textLength SQLINTEGER) (ret SQLRETURN) { + trc.Trace1("api/zapi_unix.go SQLPrepare() - ENTRY") + trc.Trace1(fmt.Sprintf("statementText=%s, textLength=%d", statementText, textLength)) + + r := C.SQLPrepareW(C.SQLHSTMT(statementHandle), (*C.SQLWCHAR)(unsafe.Pointer(statementText)), C.SQLINTEGER(textLength)) + + trc.Trace1(fmt.Sprintf("r = %d", r)) + trc.Trace1("api/zapi_unix.go SQLPrepare() - EXIT") + return SQLRETURN(r) +} + +func SQLRowCount(statementHandle SQLHSTMT, rowCountPtr *SQLLEN) (ret SQLRETURN) { + trc.Trace1("api/zapi_unix.go SQLRowCount() - ENTRY") + + r := C.SQLRowCount(C.SQLHSTMT(statementHandle), (*C.SQLLEN)(rowCountPtr)) + + trc.Trace1(fmt.Sprintf("r = %d", r)) + trc.Trace1("api/zapi_unix.go SQLRowCount() - EXIT") + return SQLRETURN(r) +} + +func SQLSetEnvAttr(environmentHandle SQLHENV, attribute SQLINTEGER, valuePtr SQLPOINTER, stringLength SQLINTEGER) (ret SQLRETURN) { + trc.Trace1("api/zapi_unix.go SQLSetEnvAttr() - ENTRY") + trc.Trace1(fmt.Sprintf("attribute=%d, valuePtr=0x%x, stringLength=%d", attribute, valuePtr, stringLength)) + + r := C.SQLSetEnvAttr(C.SQLHENV(environmentHandle), C.SQLINTEGER(attribute), C.SQLPOINTER(valuePtr), C.SQLINTEGER(stringLength)) + + trc.Trace1(fmt.Sprintf("r = %d", r)) + trc.Trace1("api/zapi_unix.go SQLSetEnvAttr() - EXIT") + return SQLRETURN(r) +} + +func SQLSetConnectAttr(connectionHandle SQLHDBC, attribute SQLINTEGER, valuePtr SQLPOINTER, stringLength SQLINTEGER) (ret SQLRETURN) { + trc.Trace1("api/zapi_unix.go SQLSetConnectAttr() - ENTRY") + trc.Trace1(fmt.Sprintf("attribute=%d, valuePtr=0x%x, stringLength=%d", attribute, valuePtr, stringLength)) + + r := C.SQLSetConnectAttrW(C.SQLHDBC(connectionHandle), C.SQLINTEGER(attribute), C.SQLPOINTER(valuePtr), C.SQLINTEGER(stringLength)) + + trc.Trace1(fmt.Sprintf("r = %d", r)) + trc.Trace1("api/zapi_unix.go SQLSetConnectAttr() - EXIT") + return SQLRETURN(r) +} + +func SQLColAttribute(statementHandle SQLHSTMT, ColumnNumber SQLUSMALLINT, FieldIdentifier SQLUSMALLINT, CharacterAttributePtr SQLPOINTER, BufferLength SQLSMALLINT, StringLengthPtr *SQLSMALLINT, NumericAttributePtr SQLPOINTER) (ret SQLRETURN) { + trc.Trace1("api/zapi_unix.go SQLColAttribute() - ENTRY") + trc.Trace1(fmt.Sprintf("ColumnNumber=%d, FieldIdentifier=%d, CharacterAttributePtr=0x%x, BufferLength=%d, StringLengthPtr=0x%x, NumericAttributePtr=0x%x", ColumnNumber, FieldIdentifier, CharacterAttributePtr, BufferLength, StringLengthPtr, NumericAttributePtr)) + + r := C.SQLColAttribute(C.SQLHSTMT(statementHandle), C.SQLUSMALLINT(ColumnNumber), C.SQLUSMALLINT(FieldIdentifier), C.SQLPOINTER(CharacterAttributePtr), C.SQLSMALLINT(BufferLength),(*C.SQLSMALLINT)(unsafe.Pointer(StringLengthPtr)), (C.SQLPOINTER)(NumericAttributePtr)) + + trc.Trace1(fmt.Sprintf("r = %d", r)) + trc.Trace1("api/zapi_unix.go SQLColAttribute() - EXIT") + return SQLRETURN(r) +} + +func SQLMoreResults(statementHandle SQLHSTMT) (ret SQLRETURN) { + trc.Trace1("api/zapi_unix.go SQLMoreResults() - ENTRY") + + r := C.SQLMoreResults(C.SQLHSTMT(statementHandle)) + + trc.Trace1(fmt.Sprintf("r = %d", r)) + trc.Trace1("api/zapi_unix.go SQLMoreResults() - EXIT") + return SQLRETURN(r) +} + +func SQLSetStmtAttr(statementHandle SQLHSTMT, attribute SQLINTEGER, valuePtr SQLPOINTER, stringLength SQLINTEGER) (ret SQLRETURN) { + trc.Trace1("api/zapi_unix.go SQLSetStmtAttr() - ENTRY") + trc.Trace1(fmt.Sprintf("attribute=%d, stringLength=%d", attribute, stringLength)) + + r := C.SQLSetStmtAttrW(C.SQLHSTMT(statementHandle), C.SQLINTEGER(attribute), C.SQLPOINTER(valuePtr), C.SQLINTEGER(stringLength)) + + trc.Trace1(fmt.Sprintf("r = %d", r)) + trc.Trace1("api/zapi_unix.go SQLSetStmtAttr() - EXIT") + return SQLRETURN(r) +} + +func SQLCreateDb(connectionHandle SQLHDBC, dbnamePtr *SQLWCHAR, dbnameLen SQLINTEGER, codeSetPtr *SQLWCHAR, codeSetLen SQLINTEGER, modePtr *SQLWCHAR, modeLen SQLINTEGER) (ret SQLRETURN) { + trc.Trace1("api/zapi_unix.go SQLCreateDb() - ENTRY") + trc.Trace1(fmt.Sprintf("dbnamePtr=%x,dbnameLen=%d, codeSetPtr=%x, codeSetLen=%d, modePtr=%x, modeLen=%d", dbnamePtr, dbnameLen, codeSetPtr, codeSetLen, modePtr, modeLen)) + + r := C.SQLCreateDbW(C.SQLHDBC(connectionHandle), (*C.SQLWCHAR)(unsafe.Pointer(dbnamePtr)), C.SQLINTEGER(dbnameLen), (*C.SQLWCHAR)(unsafe.Pointer(codeSetPtr)), C.SQLINTEGER(codeSetLen), (*C.SQLWCHAR)(unsafe.Pointer(modePtr)), C.SQLINTEGER(modeLen)) + + trc.Trace1(fmt.Sprintf("r = %d", r)) + trc.Trace1("api/zapi_unix.go SQLCreateDb() - EXIT") + return SQLRETURN(r) +} + +func SQLDropDb(connectionHandle SQLHDBC, dbnamePtr *SQLWCHAR, dbnameLen SQLINTEGER) (ret SQLRETURN) { + trc.Trace1("api/zapi_unix.go SQLDropDb() - ENTRY") + trc.Trace1(fmt.Sprintf("dbnamePtr=%x, dbnameLen=%d", dbnamePtr, dbnameLen)) + + r := C.SQLDropDbW(C.SQLHDBC(connectionHandle), (*C.SQLWCHAR)(unsafe.Pointer(dbnamePtr)), C.SQLINTEGER(dbnameLen)) + + trc.Trace1("api/zapi_unix.go SQLDropDb() - EXIT") + return SQLRETURN(r) +} + +func SQLExecDirect(statementHandle SQLHSTMT, statementText *SQLWCHAR, textLength SQLINTEGER) (ret SQLRETURN) { + trc.Trace1("api/zapi_unix.go SQLExecDirect() - ENTRY") + trc.Trace1(fmt.Sprintf("statementText=%s, textLength=%d", statementText, textLength)) + + r := C.SQLExecDirectW(C.SQLHSTMT(statementHandle), (*C.SQLWCHAR)(unsafe.Pointer(statementText)), C.SQLINTEGER(textLength)) + + trc.Trace1(fmt.Sprintf("r = %d", r)) + trc.Trace1("api/zapi_unix.go SQLExecDirect() - EXIT") + return SQLRETURN(r) +} diff --git a/vendor/github.com/ibmdb/go_ibm_db/api/zapi_windows.go b/vendor/github.com/ibmdb/go_ibm_db/api/zapi_windows.go new file mode 100644 index 00000000..356fbb26 --- /dev/null +++ b/vendor/github.com/ibmdb/go_ibm_db/api/zapi_windows.go @@ -0,0 +1,414 @@ +// mksyscall_windows.pl api.go +// MACHINE GENERATED BY THE COMMAND ABOVE; DO NOT EDIT + +package api + +import ( + "os" + "syscall" + "unsafe" + trc "github.com/ibmdb/go_ibm_db/log2" + "fmt" +) + +var ( + mododbc32 = syscall.NewLazyDLL(GetDllName()) + + procSQLAllocHandle = mododbc32.NewProc("SQLAllocHandle") + procSQLBindCol = mododbc32.NewProc("SQLBindCol") + procSQLBindParameter = mododbc32.NewProc("SQLBindParameter") + procSQLCloseCursor = mododbc32.NewProc("SQLCloseCursor") + procSQLDescribeColW = mododbc32.NewProc("SQLDescribeColW") + procSQLDescribeParam = mododbc32.NewProc("SQLDescribeParam") + procSQLDisconnect = mododbc32.NewProc("SQLDisconnect") + procSQLDriverConnectW = mododbc32.NewProc("SQLDriverConnectW") + procSQLEndTran = mododbc32.NewProc("SQLEndTran") + procSQLExecute = mododbc32.NewProc("SQLExecute") + procSQLFetch = mododbc32.NewProc("SQLFetch") + procSQLFetchScroll = mododbc32.NewProc("SQLFetchScroll") + procSQLFreeHandle = mododbc32.NewProc("SQLFreeHandle") + procSQLGetData = mododbc32.NewProc("SQLGetData") + procSQLGetDiagRecW = mododbc32.NewProc("SQLGetDiagRecW") + procSQLNumParams = mododbc32.NewProc("SQLNumParams") + procSQLNumResultCols = mododbc32.NewProc("SQLNumResultCols") + procSQLPrepareW = mododbc32.NewProc("SQLPrepareW") + procSQLExecDirectW = mododbc32.NewProc("SQLExecDirectW") + procSQLRowCount = mododbc32.NewProc("SQLRowCount") + procSQLSetEnvAttr = mododbc32.NewProc("SQLSetEnvAttr") + procSQLSetConnectAttrW = mododbc32.NewProc("SQLSetConnectAttrW") + procSQLColAttribute = mododbc32.NewProc("SQLColAttribute") + procSQLMoreResults = mododbc32.NewProc("SQLMoreResults") + procSQLSetStmtAttr = mododbc32.NewProc("SQLSetStmtAttr") + procSQLSetStmtAttrW = mododbc32.NewProc("SQLSetStmtAttrW") + procSQLGetStmtAttr = mododbc32.NewProc("SQLGetStmtAttr") + procSQLSetPos = mododbc32.NewProc("SQLSetPos") + procSQLBulkOperations = mododbc32.NewProc("SQLBulkOperations") + procSQLCreateDb = mododbc32.NewProc("SQLCreateDbW") + procSQLDropDb = mododbc32.NewProc("SQLDropDbW") +) + +func GetDllName() string { + trc.Trace1("api/zapi_windows.go GetDllName()") + if winArch := os.Getenv("PROCESSOR_ARCHITECTURE"); winArch == "x86" { + trc.Trace1("winArch is x86 and db2cli.dll") + return "db2cli.dll" + } else { + trc.Trace1("db2cli64.dll") + return "db2cli64.dll" + } +} + +func SQLAllocHandle(handleType SQLSMALLINT, inputHandle SQLHANDLE, outputHandle *SQLHANDLE) (ret SQLRETURN) { + trc.Trace1("api/zapi_windows.go SQLAllocHandle() - ENTRY") + trc.Trace1(fmt.Sprintf("handleType=%d", handleType)) + + r0, _, _ := syscall.Syscall(procSQLAllocHandle.Addr(), 3, uintptr(handleType), uintptr(inputHandle), uintptr(unsafe.Pointer(outputHandle))) + ret = SQLRETURN(r0) + + trc.Trace1(fmt.Sprintf("ret = %d", ret)) + trc.Trace1("api/zapi_windows.go SQLAllocHandle()- EXIT") + return +} + +func SQLBindCol(statementHandle SQLHSTMT, columnNumber SQLUSMALLINT, targetType SQLSMALLINT, targetValuePtr []byte, bufferLength SQLLEN, vallen *SQLLEN) (ret SQLRETURN) { + trc.Trace1("api/zapi_windows.go SQLBindCol() - ENTRY") + trc.Trace1(fmt.Sprintf("columnNumber=%d, targetType=%d, bufferLength=%d", columnNumber, targetType, bufferLength)) + + r0, _, _ := syscall.Syscall6(procSQLBindCol.Addr(), 6, uintptr(statementHandle), uintptr(columnNumber), uintptr(targetType), uintptr(unsafe.Pointer(&targetValuePtr[0])), uintptr(bufferLength), uintptr(unsafe.Pointer(vallen))) + ret = SQLRETURN(r0) + + trc.Trace1(fmt.Sprintf("ret = %d", ret)) + trc.Trace1("api/zapi_windows.go SQLBindCol()- EXIT") + return +} + +func SQLBindParameter(statementHandle SQLHSTMT, parameterNumber SQLUSMALLINT, inputOutputType SQLSMALLINT, valueType SQLSMALLINT, parameterType SQLSMALLINT, columnSize SQLULEN, decimalDigits SQLSMALLINT, parameterValue SQLPOINTER, bufferLength SQLLEN, ind *SQLLEN) (ret SQLRETURN) { + trc.Trace1("api/zapi_windows.go SQLBindParameter() - ENTRY") + trc.Trace1(fmt.Sprintf("parameterNumber=%d, inputOutputType=%d, valueType=%d, parameterType=%d, columnSize=%d, decimalDigits=%d, parameterValue=%x, bufferLength=%d", parameterNumber, inputOutputType, valueType, parameterType, columnSize, decimalDigits, parameterValue, bufferLength)) + + r0, _, _ := syscall.Syscall12(procSQLBindParameter.Addr(), 10, uintptr(statementHandle), uintptr(parameterNumber), uintptr(inputOutputType), uintptr(valueType), uintptr(parameterType), uintptr(columnSize), uintptr(decimalDigits), uintptr(parameterValue), uintptr(bufferLength), uintptr(unsafe.Pointer(ind)), 0, 0) + ret = SQLRETURN(r0) + + trc.Trace1(fmt.Sprintf("ret = %d", ret)) + trc.Trace1("api/zapi_windows.go SQLBindParameter()- EXIT") + return +} + +func SQLCloseCursor(statementHandle SQLHSTMT) (ret SQLRETURN) { + trc.Trace1("api/zapi_windows.go SQLCloseCursor() - ENTRY") + + r0, _, _ := syscall.Syscall(procSQLCloseCursor.Addr(), 1, uintptr(statementHandle), 0, 0) + ret = SQLRETURN(r0) + + trc.Trace1(fmt.Sprintf("ret = %d", ret)) + trc.Trace1("api/zapi_windows.go SQLCloseCursor() - EXIT") + return +} + +func SQLDescribeCol(statementHandle SQLHSTMT, columnNumber SQLUSMALLINT, columnName *SQLWCHAR, bufferLength SQLSMALLINT, nameLengthPtr *SQLSMALLINT, dataTypePtr *SQLSMALLINT, columnSizePtr *SQLULEN, decimalDigitsPtr *SQLSMALLINT, nullablePtr *SQLSMALLINT) (ret SQLRETURN) { + trc.Trace1("api/zapi_windows.go SQLDescribeCol() - ENTRY") + trc.Trace1(fmt.Sprintf("columnNumber=%d, columnName=%s, bufferLength=%d, nameLengthPtr=0x%x, dataTypePtr=0x%x, columnSizePtr=0x%x, decimalDigitsPtr=%x, nullablePtr=0x%x", columnNumber, *columnName, bufferLength, nameLengthPtr, dataTypePtr, columnSizePtr, decimalDigitsPtr, nullablePtr)) + + r0, _, _ := syscall.Syscall9(procSQLDescribeColW.Addr(), 9, uintptr(statementHandle), uintptr(columnNumber), uintptr(unsafe.Pointer(columnName)), uintptr(bufferLength), uintptr(unsafe.Pointer(nameLengthPtr)), uintptr(unsafe.Pointer(dataTypePtr)), uintptr(unsafe.Pointer(columnSizePtr)), uintptr(unsafe.Pointer(decimalDigitsPtr)), uintptr(unsafe.Pointer(nullablePtr))) + ret = SQLRETURN(r0) + + trc.Trace1(fmt.Sprintf("ret = %d", ret)) + trc.Trace1("api/zapi_windows.go SQLDescribeCol()- EXIT") + return +} + +func SQLDescribeParam(statementHandle SQLHSTMT, parameterNumber SQLUSMALLINT, dataTypePtr *SQLSMALLINT, parameterSizePtr *SQLULEN, decimalDigitsPtr *SQLSMALLINT, nullablePtr *SQLSMALLINT) (ret SQLRETURN) { + trc.Trace1("api/zapi_windows.go SQLDescribeParam() - ENTRY") + trc.Trace1(fmt.Sprintf("parameterNumber=%d, dataTypePtr=%x, parameterSizePtr=%x, decimalDigitsPtr=%x, nullablePtr=%x", parameterNumber, dataTypePtr, parameterSizePtr, decimalDigitsPtr, nullablePtr)) + + r0, _, _ := syscall.Syscall6(procSQLDescribeParam.Addr(), 6, uintptr(statementHandle), uintptr(parameterNumber), uintptr(unsafe.Pointer(dataTypePtr)), uintptr(unsafe.Pointer(parameterSizePtr)), uintptr(unsafe.Pointer(decimalDigitsPtr)), uintptr(unsafe.Pointer(nullablePtr))) + ret = SQLRETURN(r0) + + trc.Trace1(fmt.Sprintf("ret = %d", ret)) + trc.Trace1("api/zapi_windows.go SQLDescribeParam()- EXIT") + return +} + +func SQLDisconnect(connectionHandle SQLHDBC) (ret SQLRETURN) { + trc.Trace1("api/zapi_windows.go SQLDisconnect() - ENTRY") + + r0, _, _ := syscall.Syscall(procSQLDisconnect.Addr(), 1, uintptr(connectionHandle), 0, 0) + ret = SQLRETURN(r0) + + trc.Trace1(fmt.Sprintf("ret = %d", ret)) + trc.Trace1("api/zapi_windows.go SQLDisconnect()- EXIT") + return +} + +func SQLDriverConnect(connectionHandle SQLHDBC, windowHandle SQLHWND, inConnectionString *SQLWCHAR, stringLength1 SQLSMALLINT, outConnectionString *SQLWCHAR, bufferLength SQLSMALLINT, stringLength2Ptr *SQLSMALLINT, driverCompletion SQLUSMALLINT) (ret SQLRETURN) { + trc.Trace1("api/zapi_windows.go SQLDriverConnect()- ENTRY") + trc.Trace1(fmt.Sprintf("inConnectionString=%s, stringLength1=%d, outConnectionString=%s, bufferLength=%d, stringLength2Ptr=%x, driverCompletion=%d", inConnectionString, stringLength1, outConnectionString, bufferLength, stringLength2Ptr, driverCompletion)) + + r0, _, _ := syscall.Syscall9(procSQLDriverConnectW.Addr(), 8, uintptr(connectionHandle), uintptr(windowHandle), uintptr(unsafe.Pointer(inConnectionString)), uintptr(stringLength1), uintptr(unsafe.Pointer(outConnectionString)), uintptr(bufferLength), uintptr(unsafe.Pointer(stringLength2Ptr)), uintptr(driverCompletion), 0) + ret = SQLRETURN(r0) + + trc.Trace1(fmt.Sprintf("ret = %d", ret)) + trc.Trace1("api/zapi_windows.go SQLDriverConnect()- EXIT") + return +} + +func SQLEndTran(handleType SQLSMALLINT, handle SQLHANDLE, completionType SQLSMALLINT) (ret SQLRETURN) { + trc.Trace1("api/zapi_windows.go SQLEndTran() - ENTRY") + trc.Trace1(fmt.Sprintf("completionType=%d", completionType)) + + r0, _, _ := syscall.Syscall(procSQLEndTran.Addr(), 3, uintptr(handleType), uintptr(handle), uintptr(completionType)) + ret = SQLRETURN(r0) + + trc.Trace1(fmt.Sprintf("ret = %d", ret)) + trc.Trace1("api/zapi_windows.go SQLEndTran()- EXIT") + return +} + +func SQLExecute(statementHandle SQLHSTMT) (ret SQLRETURN) { + trc.Trace1("api/zapi_windows.go SQLExecute() - ENTRY") + + r0, _, _ := syscall.Syscall(procSQLExecute.Addr(), 1, uintptr(statementHandle), 0, 0) + ret = SQLRETURN(r0) + + trc.Trace1(fmt.Sprintf("ret = %d", ret)) + trc.Trace1("api/zapi_windows.go SQLExecute()- EXIT") + return +} + +func SQLFetch(statementHandle SQLHSTMT) (ret SQLRETURN) { + trc.Trace1("api/zapi_windows.go SQLFetch() - ENTRY") + + r0, _, _ := syscall.Syscall(procSQLFetch.Addr(), 1, uintptr(statementHandle), 0, 0) + ret = SQLRETURN(r0) + + trc.Trace1(fmt.Sprintf("ret = %d", ret)) + trc.Trace1("api/zapi_windows.go SQLFetch()- EXIT") + return +} + +func SQLFetchScroll(statementHandle SQLHSTMT, fetchOrientation SQLUSMALLINT, fetchOffset SQLLEN) (ret SQLRETURN) { + trc.Trace1("api/zapi_windows.go SQLFetchScroll() - ENTRY") + trc.Trace1(fmt.Sprintf("fetchOrientation=%d, fetchOffset=%d", fetchOrientation, fetchOffset)) + + r0, _, _ := syscall.Syscall(procSQLFetch.Addr(), 3, uintptr(statementHandle), uintptr(fetchOrientation), uintptr(fetchOffset)) + ret = SQLRETURN(r0) + + trc.Trace1(fmt.Sprintf("ret = %d", ret)) + trc.Trace1("api/zapi_windows.go SQLFetchScroll()- EXIT") + return +} + +func SQLFreeHandle(handleType SQLSMALLINT, handle SQLHANDLE) (ret SQLRETURN) { + trc.Trace1("api/zapi_windows.go SQLFreeHandle() - ENTRY") + trc.Trace1(fmt.Sprintf("handleType=%d", handleType)) + + r0, _, _ := syscall.Syscall(procSQLFreeHandle.Addr(), 2, uintptr(handleType), uintptr(handle), 0) + ret = SQLRETURN(r0) + + trc.Trace1(fmt.Sprintf("ret = %d", ret)) + trc.Trace1("api/zapi_windows.go SQLFreeHandle()- EXIT") + return +} + +func SQLGetData(statementHandle SQLHSTMT, colOrParamNum SQLUSMALLINT, targetType SQLSMALLINT, targetValuePtr SQLPOINTER, bufferLength SQLLEN, vallen *SQLLEN) (ret SQLRETURN) { + trc.Trace1("api/zapi_windows.go SQLGetData() - ENTRY") + trc.Trace1(fmt.Sprintf("colOrParamNum=%d, targetType=%d, targetValuePtr=%x, bufferLength=%d, vallen=%d", colOrParamNum, targetType, targetValuePtr, bufferLength, vallen)) + + r0, _, _ := syscall.Syscall6(procSQLGetData.Addr(), 6, uintptr(statementHandle), uintptr(colOrParamNum), uintptr(targetType), uintptr(targetValuePtr), uintptr(bufferLength), uintptr(unsafe.Pointer(vallen))) + ret = SQLRETURN(r0) + + trc.Trace1(fmt.Sprintf("ret = %d", ret)) + trc.Trace1("api/zapi_windows.go SQLGetData()- EXIT") + return +} + +func SQLGetDiagRec(handleType SQLSMALLINT, handle SQLHANDLE, recNumber SQLSMALLINT, sqlState *SQLWCHAR, nativeErrorPtr *SQLINTEGER, messageText *SQLWCHAR, bufferLength SQLSMALLINT, textLengthPtr *SQLSMALLINT) (ret SQLRETURN) { + trc.Trace1("api/zapi_windows.go SQLGetDiagRec() - ENTRY") + trc.Trace1(fmt.Sprintf("handleType=%d, recNumber=%d, sqlState=%s, nativeErrorPtr=%x, messageText=%s, bufferLength=%d, textLengthPtr=%x", handleType, recNumber, sqlState, nativeErrorPtr, messageText, bufferLength, textLengthPtr)) + + r0, _, _ := syscall.Syscall9(procSQLGetDiagRecW.Addr(), 8, uintptr(handleType), uintptr(handle), uintptr(recNumber), uintptr(unsafe.Pointer(sqlState)), uintptr(unsafe.Pointer(nativeErrorPtr)), uintptr(unsafe.Pointer(messageText)), uintptr(bufferLength), uintptr(unsafe.Pointer(textLengthPtr)), 0) + ret = SQLRETURN(r0) + + trc.Trace1(fmt.Sprintf("ret = %d", ret)) + trc.Trace1("api/zapi_windows.go SQLGetDiagRec()- EXIT") + return +} + +func SQLNumParams(statementHandle SQLHSTMT, parameterCountPtr *SQLSMALLINT) (ret SQLRETURN) { + trc.Trace1("api/zapi_windows.go SQLNumParams() - ENTRY") + trc.Trace1(fmt.Sprintf("parameterCountPtr=%x", parameterCountPtr)) + + r0, _, _ := syscall.Syscall(procSQLNumParams.Addr(), 2, uintptr(statementHandle), uintptr(unsafe.Pointer(parameterCountPtr)), 0) + ret = SQLRETURN(r0) + + trc.Trace1(fmt.Sprintf("ret = %d", ret)) + trc.Trace1("api/zapi_windows.go SQLNumParams()- EXIT") + return +} + +func SQLNumResultCols(statementHandle SQLHSTMT, columnCountPtr *SQLSMALLINT) (ret SQLRETURN) { + trc.Trace1("api/zapi_windows.go SQLNumResultCols() - ENTRY") + trc.Trace1(fmt.Sprintf("columnCountPtr=%x", columnCountPtr)) + + r0, _, _ := syscall.Syscall(procSQLNumResultCols.Addr(), 2, uintptr(statementHandle), uintptr(unsafe.Pointer(columnCountPtr)), 0) + ret = SQLRETURN(r0) + + trc.Trace1(fmt.Sprintf("ret = %d", ret)) + trc.Trace1("api/zapi_windows.go SQLNumResultCols()- EXIT") + return +} + +func SQLPrepare(statementHandle SQLHSTMT, statementText *SQLWCHAR, textLength SQLINTEGER) (ret SQLRETURN) { + trc.Trace1("api/zapi_windows.go SQLPrepare() - ENTRY") + trc.Trace1(fmt.Sprintf("statementText=%s, textLength=%d", statementText, textLength)) + + r0, _, _ := syscall.Syscall(procSQLPrepareW.Addr(), 3, uintptr(statementHandle), uintptr(unsafe.Pointer(statementText)), uintptr(textLength)) + ret = SQLRETURN(r0) + + trc.Trace1(fmt.Sprintf("ret = %d", ret)) + trc.Trace1("api/zapi_windows.go SQLPrepare()- EXIT") + return +} + +func SQLRowCount(statementHandle SQLHSTMT, rowCountPtr *SQLLEN) (ret SQLRETURN) { + trc.Trace1("api/zapi_windows.go SQLRowCount() - ENTRY") + trc.Trace1(fmt.Sprintf("rowCountPtr=0x%x", rowCountPtr)) + + r0, _, _ := syscall.Syscall(procSQLRowCount.Addr(), 2, uintptr(statementHandle), uintptr(unsafe.Pointer(rowCountPtr)), 0) + ret = SQLRETURN(r0) + + trc.Trace1(fmt.Sprintf("ret = %d", ret)) + trc.Trace1("api/zapi_windows.go SQLRowCount()- EXIT") + return +} + +func SQLSetEnvAttr(environmentHandle SQLHENV, attribute SQLINTEGER, valuePtr SQLPOINTER, stringLength SQLINTEGER) (ret SQLRETURN) { + trc.Trace1("api/zapi_windows.go SQLSetEnvAttr() - ENTRY") + trc.Trace1(fmt.Sprintf("attribute=%d, valuePtr=0x%x, stringLength=%d", attribute, valuePtr, stringLength)) + + r0, _, _ := syscall.Syscall6(procSQLSetEnvAttr.Addr(), 4, uintptr(environmentHandle), uintptr(attribute), uintptr(valuePtr), uintptr(stringLength), 0, 0) + ret = SQLRETURN(r0) + + trc.Trace1(fmt.Sprintf("ret = %d", ret)) + trc.Trace1("api/zapi_windows.go SQLSetEnvAttr()- EXIT") + return +} + +func SQLSetConnectAttr(connectionHandle SQLHDBC, attribute SQLINTEGER, valuePtr SQLPOINTER, stringLength SQLINTEGER) (ret SQLRETURN) { + trc.Trace1("api/zapi_windows.go SQLSetConnectAttr() - ENTRY") + trc.Trace1(fmt.Sprintf("attribute=%d, valuePtr=0x%x, stringLength=%d", attribute, valuePtr, stringLength)) + + r0, _, _ := syscall.Syscall6(procSQLSetConnectAttrW.Addr(), 4, uintptr(connectionHandle), uintptr(attribute), uintptr(valuePtr), uintptr(stringLength), 0, 0) + ret = SQLRETURN(r0) + + trc.Trace1(fmt.Sprintf("ret = %d", ret)) + trc.Trace1("api/zapi_windows.go SQLSetConnectAttr()- EXIT") + return +} + +func SQLColAttribute(statementHandle SQLHSTMT, ColumnNumber SQLUSMALLINT, FieldIdentifier SQLUSMALLINT, CharacterAttributePtr SQLPOINTER, BufferLength SQLSMALLINT, StringLengthPtr *SQLSMALLINT, NumericAttributePtr SQLPOINTER) (ret SQLRETURN) { + trc.Trace1("api/zapi_windows.go SQLColAttribute() - ENTRY") + trc.Trace1(fmt.Sprintf("ColumnNumber=%d, FieldIdentifier=%d, CharacterAttributePtr=0x%x, BufferLength=%d, StringLengthPtr=0x%x, NumericAttributePtr=0x%x", ColumnNumber, FieldIdentifier, CharacterAttributePtr, BufferLength, StringLengthPtr, NumericAttributePtr)) + + r0, _, _ := syscall.Syscall9(procSQLColAttribute.Addr(), 7, uintptr(statementHandle), uintptr(ColumnNumber), uintptr(FieldIdentifier), uintptr(CharacterAttributePtr), uintptr(BufferLength), uintptr(unsafe.Pointer(StringLengthPtr)), uintptr(NumericAttributePtr), 0, 0) + ret = SQLRETURN(r0) + + trc.Trace1(fmt.Sprintf("ret = %d", ret)) + trc.Trace1("api/zapi_windows.go SQLColAttribute()- EXIT") + return +} + +func SQLMoreResults(statementHandle SQLHSTMT) (ret SQLRETURN) { + trc.Trace1("api/zapi_windows.go SQLMoreResults() - ENTRY") + + r0, _, _ := syscall.Syscall(procSQLMoreResults.Addr(), 1, uintptr(statementHandle), 0, 0) + ret = SQLRETURN(r0) + + trc.Trace1(fmt.Sprintf("ret = %d", ret)) + trc.Trace1("api/zapi_windows.go SQLMoreResults()- EXIT") + return +} + +func SQLSetStmtAttr(statementHandle SQLHSTMT, attribute SQLINTEGER, valuePtr SQLPOINTER, stringLength SQLINTEGER) (ret SQLRETURN) { + trc.Trace1("api/zapi_windows.go SQLSetStmtAttr() - ENTRY") + trc.Trace1(fmt.Sprintf("attribute=%d, valuePtr=0x%x, stringLength=%d", attribute, valuePtr, stringLength)) + + r0, _, _ := syscall.Syscall6(procSQLSetStmtAttr.Addr(), 4, uintptr(statementHandle), uintptr(attribute), uintptr(valuePtr), uintptr(stringLength), 0, 0) + ret = SQLRETURN(r0) + + trc.Trace1(fmt.Sprintf("ret = %d", ret)) + trc.Trace1("api/zapi_windows.go SQLSetStmtAttr()- EXIT") + return +} + +func SQLGetStmtAttr(environmentHandle SQLHSTMT, attribute SQLINTEGER, targetValuePtr []byte, stringLength SQLINTEGER) (ret SQLRETURN) { + trc.Trace1("api/zapi_windows.go SQLGetStmtAttr() - ENTRY") + trc.Trace1(fmt.Sprintf("attribute=%d, stringLength=%d", attribute, stringLength)) + + r0, _, _ := syscall.Syscall6(procSQLGetStmtAttr.Addr(), 4, uintptr(environmentHandle), uintptr(attribute), uintptr(unsafe.Pointer(&targetValuePtr[0])), uintptr(stringLength), 0, 0) + ret = SQLRETURN(r0) + + trc.Trace1(fmt.Sprintf("ret = %d", ret)) + trc.Trace1("api/zapi_windows.go SQLGetStmtAttr()- EXIT") + return +} + +func SQLSetPos(statementHandle SQLHSTMT, rowNumber SQLSETPOSIROW, operation SQLUSMALLINT, lockType SQLUSMALLINT) (ret SQLRETURN) { + trc.Trace1("api/zapi_windows.go SQLSetPos() - ENTRY") + trc.Trace1(fmt.Sprintf("rowNumber=%d, operation=%d, lockType=%d", rowNumber, operation, lockType)) + + r0, _, _ := syscall.Syscall6(procSQLSetPos.Addr(), 4, uintptr(statementHandle), uintptr(rowNumber), uintptr(operation), uintptr(lockType), 0, 0) + ret = SQLRETURN(r0) + + trc.Trace1(fmt.Sprintf("ret = %d", ret)) + trc.Trace1("api/zapi_windows.go SQLSetPos()- EXIT") + return +} + +func SQLBulkOperations(statementHandle SQLHSTMT, operation SQLSMALLINT) (ret SQLRETURN) { + trc.Trace1("api/zapi_windows.go SQLBulkOperations() - ENTRY") + trc.Trace1(fmt.Sprintf("operation=%d", operation)) + + r0, _, _ := syscall.Syscall6(procSQLBulkOperations.Addr(), 2, uintptr(statementHandle), uintptr(operation), 0, 0, 0, 0) + ret = SQLRETURN(r0) + + trc.Trace1(fmt.Sprintf("ret = %d", ret)) + trc.Trace1("api/zapi_windows.go SQLBulkOperations()- EXIT") + return +} + +func SQLCreateDb(connectionHandle SQLHDBC, dbnamePtr *SQLWCHAR, dbnameLen SQLINTEGER, codeSetPtr *SQLWCHAR, codeSetLen SQLINTEGER, modePtr *SQLWCHAR, modeLen SQLINTEGER) (ret SQLRETURN) { + trc.Trace1("api/zapi_windows.go SQLCreateDb() - ENTRY") + trc.Trace1(fmt.Sprintf("dbnamePtr=%x,dbnameLen=%d, codeSetPtr=%x, codeSetLen=%d, modePtr=%x, modeLen=%d", dbnamePtr, dbnameLen, codeSetPtr, codeSetLen, modePtr, modeLen)) + + r0, _, _ := syscall.Syscall9(procSQLCreateDb.Addr(), 7, uintptr(connectionHandle), uintptr(unsafe.Pointer(dbnamePtr)), uintptr(dbnameLen), uintptr(unsafe.Pointer(codeSetPtr)), uintptr(codeSetLen), uintptr(unsafe.Pointer(modePtr)), uintptr(modeLen), 0, 0) + ret = SQLRETURN(r0) + + trc.Trace1(fmt.Sprintf("ret = %d", ret)) + trc.Trace1("api/zapi_windows.go SQLCreateDb()- EXIT") + return +} + +func SQLDropDb(connectionHandle SQLHDBC, dbnamePtr *SQLWCHAR, dbnameLen SQLINTEGER) (ret SQLRETURN) { + trc.Trace1("api/zapi_windows.go SQLDropDb() - ENTRY") + trc.Trace1(fmt.Sprintf("dbnamePtr=%x, dbnameLen=%d", dbnamePtr, dbnameLen)) + + r0, _, _ := syscall.Syscall(procSQLDropDb.Addr(), 3, uintptr(connectionHandle), uintptr(unsafe.Pointer(dbnamePtr)), uintptr(dbnameLen)) + ret = SQLRETURN(r0) + + trc.Trace1(fmt.Sprintf("ret = %d", ret)) + trc.Trace1("api/zapi_windows.go SQLDropDb()- EXIT") + return +} + +func SQLExecDirect(statementHandle SQLHSTMT, statementText *SQLWCHAR, textLength SQLINTEGER) (ret SQLRETURN) { + trc.Trace1("api/zapi_windows.go SQLExecDirect() - ENTRY") + trc.Trace1(fmt.Sprintf("statementText=%s, textLength=%d", statementText, textLength)) + + r0, _, _ := syscall.Syscall(procSQLExecDirectW.Addr(), 3, uintptr(statementHandle), uintptr(unsafe.Pointer(statementText)), uintptr(textLength)) + ret = SQLRETURN(r0) + + trc.Trace1(fmt.Sprintf("ret = %d", ret)) + trc.Trace1("api/zapi_windows.go SQLExecDirect()- EXIT") + return +} diff --git a/vendor/github.com/ibmdb/go_ibm_db/api/zapi_zos.go b/vendor/github.com/ibmdb/go_ibm_db/api/zapi_zos.go new file mode 100644 index 00000000..c611ad96 --- /dev/null +++ b/vendor/github.com/ibmdb/go_ibm_db/api/zapi_zos.go @@ -0,0 +1,264 @@ +// Copyright 2024 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +//go:build zos + +package api + +import ( + "fmt" + "os" + "unsafe" + + "github.com/ibmruntimes/go-recordio/v2/utils" + trc "github.com/ibmdb/go_ibm_db/log2" +) + +var dll utils.Dll + +func init() { + var e error + e = dll.Open("DSNAO64C") + if e != nil { + fmt.Fprintf(os.Stderr, "Failed to load DLL %s\n", "DSNAO64C") + os.Exit(1) + } +} + +func SQLAllocHandle(handleType SQLSMALLINT, inputHandle SQLHANDLE, outputHandle *SQLHANDLE) (SQLRETURN) { + trc.Trace1("api/zapi_zos.go SQLAllocHandle() - ENTRY") + trc.Trace1(fmt.Sprintf("handleType = %d", handleType)) + + r := utils.CfuncEbcdic(getFunc(&dll, "SQLAllocHandle"), uintptr(handleType), uintptr(inputHandle), uintptr(unsafe.Pointer(outputHandle))) + + trc.Trace1(fmt.Sprintf("r = %d", r)) + trc.Trace1("api/zapi_zos.go SQLAllocHandle() - EXIT") + return SQLRETURN(r) +} + +func SQLBindCol(statementHandle SQLHSTMT, columnNumber SQLUSMALLINT, targetType SQLSMALLINT, targetValuePtr []byte, bufferLength SQLLEN, vallen *SQLLEN) (SQLRETURN) { + trc.Trace1("api/zapi_zos.go SQLBindCol() - ENTRY") + trc.Trace1(fmt.Sprintf("columnNumber=%d, targetType=%d, bufferLength=%d, vallen=%d", columnNumber, targetType, bufferLength, vallen)) + + r := utils.CfuncEbcdic(getFunc(&dll, "SQLBindCol"), uintptr(statementHandle), uintptr(columnNumber), uintptr(targetType), uintptr(unsafe.Pointer(&targetValuePtr[0])), uintptr(bufferLength), uintptr(unsafe.Pointer(vallen))) + + trc.Trace1("api/zapi_zos.go SQLBindCol() - EXIT") + return SQLRETURN(r) +} + +func SQLBindParameter(statementHandle SQLHSTMT, parameterNumber SQLUSMALLINT, inputOutputType SQLSMALLINT, valueType SQLSMALLINT, parameterType SQLSMALLINT, columnSize SQLULEN, decimalDigits SQLSMALLINT, parameterValue SQLPOINTER, bufferLength SQLLEN, ind *SQLLEN) (SQLRETURN) { + trc.Trace1("api/zapi_zos.go SQLBindParameter() - ENTRY") + + r := utils.CfuncEbcdic(getFunc(&dll, "SQLBindParameter"), uintptr(statementHandle), uintptr(parameterNumber), uintptr(inputOutputType), uintptr(valueType), uintptr(parameterType), uintptr(columnSize), uintptr(decimalDigits), uintptr(parameterValue), uintptr(bufferLength), uintptr(unsafe.Pointer(ind))) + + trc.Trace1("api/zapi_zos.go SQLBindParameter() - EXIT") + return SQLRETURN(r) +} + +func SQLCloseCursor(statementHandle SQLHSTMT) (SQLRETURN) { + trc.Trace1("api/zapi_zos.go SQLCloseCursor() - ENTRY") + + r := utils.CfuncEbcdic(getFunc(&dll, "SQLCloseCursor"), uintptr(statementHandle)) + + trc.Trace1("api/zapi_zos.go SQLCloseCursor() - EXIT") + return SQLRETURN(r) +} + +func SQLDescribeCol(statementHandle SQLHSTMT, columnNumber SQLUSMALLINT, columnName *SQLWCHAR, bufferLength SQLSMALLINT, nameLengthPtr *SQLSMALLINT, dataTypePtr *SQLSMALLINT, columnSizePtr *SQLULEN, decimalDigitsPtr *SQLSMALLINT, nullablePtr *SQLSMALLINT) SQLRETURN { + trc.Trace1("api/zapi_zos.go SQLDescribeCol() - ENTRY") + + r := utils.CfuncEbcdic(getFunc(&dll, "SQLDescribeColW"), uintptr(statementHandle), uintptr(columnNumber), uintptr(unsafe.Pointer(columnName)), uintptr(bufferLength), uintptr(unsafe.Pointer(nameLengthPtr)), uintptr(unsafe.Pointer(dataTypePtr)), uintptr(unsafe.Pointer(columnSizePtr)), uintptr(unsafe.Pointer(decimalDigitsPtr)), uintptr(unsafe.Pointer(nullablePtr))) + + trc.Trace1("api/zapi_zos.go SQLDescribeCol() - EXIT") + return SQLRETURN(r) +} + +func SQLDescribeParam(statementHandle SQLHSTMT, parameterNumber SQLUSMALLINT, dataTypePtr *SQLSMALLINT, parameterSizePtr *SQLULEN, decimalDigitsPtr *SQLSMALLINT, nullablePtr *SQLSMALLINT) (SQLRETURN) { + trc.Trace1("api/zapi_zos.go SQLDescribeParam() - ENTRY") + + r := utils.CfuncEbcdic(getFunc(&dll, "SQLDescribeParam"), uintptr(statementHandle), uintptr(parameterNumber), uintptr(unsafe.Pointer(dataTypePtr)), uintptr(unsafe.Pointer(parameterSizePtr)), uintptr(unsafe.Pointer(decimalDigitsPtr)), uintptr(unsafe.Pointer(nullablePtr))) + + trc.Trace1("api/zapi_zos.go SQLDescribeParam() - EXIT") + return SQLRETURN(r) +} + +func SQLDisconnect(connectionHandle SQLHDBC) (SQLRETURN) { + trc.Trace1("api/zapi_zos.go SQLDisconnect() - ENTRY") + + r := utils.CfuncEbcdic(getFunc(&dll, "SQLDisconnect"), uintptr(connectionHandle)) + + trc.Trace1("api/zapi_zos.go SQLDisconnect() - EXIT") + return SQLRETURN(r) +} + +func SQLDriverConnect(connectionHandle SQLHDBC, windowHandle SQLHWND, inConnectionString *SQLWCHAR, stringLength1 SQLSMALLINT, outConnectionString *SQLWCHAR, bufferLength SQLSMALLINT, stringLength2Ptr *SQLSMALLINT, driverCompletion SQLUSMALLINT) (SQLRETURN) { + trc.Trace1("api/zapi_zos.go SQLDriverConnect() - ENTRY") + + r := utils.CfuncEbcdic(getFunc(&dll, "SQLDriverConnectW"),uintptr(connectionHandle), uintptr(windowHandle), uintptr(unsafe.Pointer(inConnectionString)), uintptr(stringLength1), uintptr(unsafe.Pointer(outConnectionString)), uintptr(bufferLength), uintptr(unsafe.Pointer(stringLength2Ptr)), uintptr(driverCompletion)) + + trc.Trace1("api/zapi_zos.go SQLDriverConnect() - EXIT") + return SQLRETURN(r) +} + +func SQLEndTran(handleType SQLSMALLINT, handle SQLHANDLE, completionType SQLSMALLINT) (SQLRETURN) { + trc.Trace1("api/zapi_zos.go SQLEndTran() - ENTRY") + + r := utils.CfuncEbcdic(getFunc(&dll, "SQLEndTran"), uintptr(handleType), uintptr(handle), uintptr(completionType)) + + trc.Trace1("api/zapi_zos.go SQLEndTran() - EXIT") + return SQLRETURN(r) +} + +func SQLExecute(statementHandle SQLHSTMT) (SQLRETURN) { + trc.Trace1("api/zapi_zos.go SQLExecute() - ENTRY") + + r := utils.CfuncEbcdic(getFunc(&dll, "SQLExecute"), uintptr(statementHandle)) + + trc.Trace1("api/zapi_zos.go SQLExecute() - EXIT") + return SQLRETURN(r) +} + +func SQLFetch(statementHandle SQLHSTMT) (SQLRETURN) { + trc.Trace1("api/zapi_zos.go SQLFetch() - ENTRY") + + r := utils.CfuncEbcdic(getFunc(&dll, "SQLFetch"), uintptr(statementHandle)) + + trc.Trace1("api/zapi_zos.go SQLFetch() - EXIT") + return SQLRETURN(r) +} + +func SQLFreeHandle(handleType SQLSMALLINT, handle SQLHANDLE) (SQLRETURN) { + trc.Trace1("api/zapi_zos.go SQLFreeHandle() - ENTRY") + + r := utils.CfuncEbcdic(getFunc(&dll, "SQLFreeHandle"), uintptr(handleType), uintptr(handle)) + + trc.Trace1("api/zapi_zos.go SQLFreeHandle() - EXIT") + return SQLRETURN(r) +} + +func SQLGetData(statementHandle SQLHSTMT, colOrParamNum SQLUSMALLINT, targetType SQLSMALLINT, targetValuePtr SQLPOINTER, bufferLength SQLLEN, vallen *SQLLEN) (SQLRETURN) { + trc.Trace1("api/zapi_zos.go SQLGetData() - ENTRY") + + r := utils.CfuncEbcdic(getFunc(&dll, "SQLGetData"), uintptr(statementHandle), uintptr(colOrParamNum), uintptr(targetType), uintptr(targetValuePtr), uintptr(bufferLength), uintptr(unsafe.Pointer(vallen))) + + trc.Trace1("api/zapi_zos.go SQLGetData() - EXIT") + return SQLRETURN(r) +} + +func SQLGetDiagRec(handleType SQLSMALLINT, handle SQLHANDLE, recNumber SQLSMALLINT, sqlState *SQLWCHAR, nativeErrorPtr *SQLINTEGER, messageText *SQLWCHAR, bufferLength SQLSMALLINT, textLengthPtr *SQLSMALLINT) (SQLRETURN) { + trc.Trace1("api/zapi_zos.go SQLGetDiagRec() - ENTRY") + + r := utils.CfuncEbcdic(getFunc(&dll, "SQLGetDiagRecW"), uintptr(handleType), uintptr(handle), uintptr(recNumber), uintptr(unsafe.Pointer(sqlState)), uintptr(unsafe.Pointer(nativeErrorPtr)), uintptr(unsafe.Pointer(messageText)), uintptr(bufferLength), uintptr(unsafe.Pointer(textLengthPtr))) + + trc.Trace1("api/zapi_zos.go SQLGetDiagRec() - EXIT") + return SQLRETURN(r) +} + +func SQLNumParams(statementHandle SQLHSTMT, parameterCountPtr *SQLSMALLINT) (SQLRETURN) { + trc.Trace1("api/zapi_zos.go SQLNumParams() - ENTRY") + + r := utils.CfuncEbcdic(getFunc(&dll, "SQLNumParams"), uintptr(statementHandle), uintptr(unsafe.Pointer(parameterCountPtr))) + + trc.Trace1("api/zapi_zos.go SQLNumParams() - EXIT") + return SQLRETURN(r) +} + +func SQLNumResultCols(statementHandle SQLHSTMT, columnCountPtr *SQLSMALLINT) (SQLRETURN) { + trc.Trace1("api/zapi_zos.go SQLNumResultCols() - ENTRY") + + r := utils.CfuncEbcdic(getFunc(&dll, "SQLNumResultCols"), uintptr(statementHandle), uintptr(unsafe.Pointer(columnCountPtr))) + + trc.Trace1("api/zapi_zos.go SQLNumResultCols() - EXIT") + return SQLRETURN(r) +} + +func SQLPrepare(statementHandle SQLHSTMT, statementText *SQLWCHAR, textLength SQLINTEGER) (SQLRETURN) { + trc.Trace1("api/zapi_zos.go SQLPrepare() - ENTRY") + + r := utils.CfuncEbcdic(getFunc(&dll, "SQLPrepareW"), uintptr(statementHandle), uintptr(unsafe.Pointer(statementText)), uintptr(textLength)) + + trc.Trace1("api/zapi_zos.go SQLPrepare() - EXIT") + return SQLRETURN(r) +} + +func SQLRowCount(statementHandle SQLHSTMT, rowCountPtr *SQLLEN) (SQLRETURN) { + trc.Trace1("api/zapi_zos.go SQLRowCount() - ENTRY") + + r := utils.CfuncEbcdic(getFunc(&dll, "SQLRowCount"), uintptr(statementHandle), uintptr(unsafe.Pointer(rowCountPtr))) + + trc.Trace1("api/zapi_zos.go SQLRowCount() - EXIT") + return SQLRETURN(r) +} + +func SQLSetEnvAttr(environmentHandle SQLHENV, attribute SQLINTEGER, valuePtr SQLPOINTER, stringLength SQLINTEGER) (SQLRETURN) { + trc.Trace1("api/zapi_zos.go SQLSetEnvAttr() - ENTRY") + + r := utils.CfuncEbcdic(getFunc(&dll, "SQLSetEnvAttr"), uintptr(environmentHandle), uintptr(attribute), uintptr(valuePtr), uintptr(stringLength)) + + trc.Trace1("api/zapi_zos.go SQLSetEnvAttr() - EXIT") + return SQLRETURN(r) +} + +func SQLSetConnectAttr(connectionHandle SQLHDBC, attribute SQLINTEGER, valuePtr SQLPOINTER, stringLength SQLINTEGER) (SQLRETURN) { + trc.Trace1("api/zapi_zos.go SQLSetConnectAttr() - ENTRY") + + r := utils.CfuncEbcdic(getFunc(&dll, "SQLSetConnectAttrW"), uintptr(connectionHandle), uintptr(attribute), uintptr(valuePtr), uintptr(stringLength)) + + trc.Trace1("api/zapi_zos.go SQLSetConnectAttr() - EXIT") + return SQLRETURN(r) +} + +func SQLColAttribute(statementHandle SQLHSTMT, ColumnNumber SQLUSMALLINT, FieldIdentifier SQLUSMALLINT, CharacterAttributePtr SQLPOINTER, BufferLength SQLSMALLINT, StringLengthPtr *SQLSMALLINT, NumericAttributePtr SQLPOINTER) (SQLRETURN) { + trc.Trace1("api/zapi_zos.go SQLColAttribute() - ENTRY") + + r := utils.CfuncEbcdic(getFunc(&dll, "SQLColAttribute"), uintptr(statementHandle), uintptr(ColumnNumber), uintptr(FieldIdentifier), uintptr(CharacterAttributePtr), uintptr(BufferLength), uintptr(unsafe.Pointer(StringLengthPtr)), uintptr(NumericAttributePtr)) + + trc.Trace1("api/zapi_zos.go SQLColAttribute() - EXIT") + return SQLRETURN(r) +} + +func SQLMoreResults(statementHandle SQLHSTMT) (SQLRETURN) { + trc.Trace1("api/zapi_zos.go SQLMoreResults() - ENTRY") + + r := utils.CfuncEbcdic(getFunc(&dll, "SQLMoreResults"), uintptr(statementHandle)) + + trc.Trace1("api/zapi_zos.go SQLMoreResults() - EXIT") + return SQLRETURN(r) +} + +func SQLSetStmtAttr(statementHandle SQLHSTMT, attribute SQLINTEGER, valuePtr SQLPOINTER, stringLength SQLINTEGER) (SQLRETURN) { + trc.Trace1("api/zapi_zos.go SQLSetStmtAttr() - ENTRY") + + r := utils.CfuncEbcdic(getFunc(&dll, "SQLSetStmtAttr"), uintptr(statementHandle), uintptr(attribute), uintptr(valuePtr), uintptr(stringLength)) + + trc.Trace1("api/zapi_zos.go SQLSetStmtAttr() - EXIT") + return SQLRETURN(r) +} + +func SQLCreateDb(connectionHandle SQLHDBC, dbnamePtr *SQLWCHAR, dbnameLen SQLINTEGER, codeSetPtr *SQLWCHAR, codeSetLen SQLINTEGER, modePtr *SQLWCHAR, modeLen SQLINTEGER) (SQLRETURN) { + trc.Trace1("api/zapi_zos.go SQLCreateDb() - ENTRY") + + r := utils.CfuncEbcdic(getFunc(&dll, "SQLCreateDbW"), uintptr(connectionHandle), uintptr(unsafe.Pointer(dbnamePtr)), uintptr(dbnameLen), uintptr(unsafe.Pointer(codeSetPtr)), uintptr(codeSetLen), uintptr(unsafe.Pointer(modePtr)), uintptr(modeLen)) + + trc.Trace1("api/zapi_zos.go SQLCreateDb() - EXIT") + return SQLRETURN(r) +} + +func SQLDropDb(connectionHandle SQLHDBC, dbnamePtr *SQLWCHAR, dbnameLen SQLINTEGER) (SQLRETURN) { + trc.Trace1("api/zapi_zos.go SQLDropDb() - ENTRY") + + r := utils.CfuncEbcdic(getFunc(&dll, "SQLDropDbW"), uintptr(connectionHandle), uintptr(unsafe.Pointer(dbnamePtr)), uintptr(dbnameLen)) + + trc.Trace1("api/zapi_zos.go SQLDropDb() - EXIT") + return SQLRETURN(r) +} + +func SQLExecDirect(statementHandle SQLHSTMT, statementText *SQLWCHAR, textLength SQLINTEGER) (SQLRETURN) { + trc.Trace1("api/zapi_zos.go SQLExecDirect() - ENTRY") + + r := utils.CfuncEbcdic(getFunc(&dll, "SQLExecDirectW"), uintptr(statementHandle), uintptr(unsafe.Pointer(statementText)), uintptr(textLength)) + + trc.Trace1("api/zapi_zos.go SQLExecDirect() - EXIT") + return SQLRETURN(r) +} diff --git a/vendor/github.com/ibmdb/go_ibm_db/column.go b/vendor/github.com/ibmdb/go_ibm_db/column.go new file mode 100644 index 00000000..932c9b53 --- /dev/null +++ b/vendor/github.com/ibmdb/go_ibm_db/column.go @@ -0,0 +1,391 @@ +// Copyright 2012 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package go_ibm_db + +import ( + "database/sql/driver" + "errors" + "fmt" + "reflect" + "time" + "unsafe" + "bytes" + + "github.com/ibmdb/go_ibm_db/api" + trc "github.com/ibmdb/go_ibm_db/log2" +) + +type BufferLen api.SQLLEN + +func (l *BufferLen) IsNull() bool { + trc.Trace1("column.go: IsNull()") + + return int16(*l) == api.SQL_NULL_DATA +} + +func (l *BufferLen) GetData(h api.SQLHSTMT, idx int, ctype api.SQLSMALLINT, buf []byte) api.SQLRETURN { + trc.Trace1("column.go: GetData()") + + return api.SQLGetData(h, api.SQLUSMALLINT(idx+1), ctype, + api.SQLPOINTER(unsafe.Pointer(&buf[0])), api.SQLLEN(len(buf)), + (*api.SQLLEN)(l)) +} + +func (l *BufferLen) Bind(h api.SQLHSTMT, idx int, ctype api.SQLSMALLINT, buf []byte) api.SQLRETURN { + trc.Trace1("column.go: Bind()- ENTRY") + + if len(buf) <= 2147483647 { + return api.SQLBindCol(h, api.SQLUSMALLINT(idx+1), ctype, + buf, api.SQLLEN(len(buf)), + (*api.SQLLEN)(l)) + } + trc.Trace1("column.go: Bind()- EXIT") + return api.SQLBindCol(h, api.SQLUSMALLINT(idx+1), ctype, + buf, api.SQLLEN(len(buf)-1), + (*api.SQLLEN)(l)) +} + +// Column provides access to row columns. +type Column interface { + Name() string + TypeScan() reflect.Type + Bind(h api.SQLHSTMT, idx int) (bool, error) + Value(h api.SQLHSTMT, idx int) (driver.Value, error) +} + +func describeColumn(h api.SQLHSTMT, idx int, namebuf []uint16) (namelen int, sqltype api.SQLSMALLINT, size api.SQLULEN, ret api.SQLRETURN) { + trc.Trace1("column.go: describeColumn() - ENTRY") + + var l, decimal, nullable api.SQLSMALLINT + ret = api.SQLDescribeCol(h, api.SQLUSMALLINT(idx+1), + (*api.SQLWCHAR)(unsafe.Pointer(&namebuf[0])), + api.SQLSMALLINT(len(namebuf)), &l, + &sqltype, &size, &decimal, &nullable) + + trc.Trace1("column.go: describeColumn() - EXIT") + return int(l), sqltype, size, ret +} + +// TODO(brainman): did not check for MS SQL timestamp + +func NewColumn(h api.SQLHSTMT, idx int) (Column, error) { + trc.Trace1("column.go: NewColumn() - ENTRY") + + namebuf := make([]uint16, 150) + namelen, sqltype, size, ret := describeColumn(h, idx, namebuf) + if ret == api.SQL_SUCCESS_WITH_INFO && namelen > len(namebuf) { + // try again with bigger buffer + namebuf = make([]uint16, namelen) + namelen, sqltype, size, ret = describeColumn(h, idx, namebuf) + } + if IsError(ret) { + return nil, NewError("SQLDescribeCol", h) + } + if namelen > len(namebuf) { + // still complaining about buffer size + return nil, errors.New("Failed to allocate column name buffer") + } + b := &BaseColumn{ + name: api.UTF16ToString(namebuf[:namelen]), + SType: sqltype, + } + + trc.Trace1("column.go: NewColumn() - EXIT") + + switch sqltype { + case api.SQL_BIT, api.SQL_BOOLEAN: + return NewBindableColumn(b, api.SQL_C_BIT, 1), nil + case api.SQL_TINYINT, api.SQL_SMALLINT, api.SQL_INTEGER: + return NewBindableColumn(b, api.SQL_C_LONG, 4), nil + case api.SQL_BIGINT: + return NewBindableColumn(b, api.SQL_C_SBIGINT, 8), nil + case api.SQL_NUMERIC, api.SQL_FLOAT, api.SQL_REAL, api.SQL_DOUBLE: + return NewBindableColumn(b, api.SQL_C_DOUBLE, 8), nil + case api.SQL_TYPE_TIMESTAMP: + var v api.SQL_TIMESTAMP_STRUCT + return NewBindableColumn(b, api.SQL_C_TYPE_TIMESTAMP, int(unsafe.Sizeof(v))), nil + case api.SQL_TYPE_DATE: + var v api.SQL_DATE_STRUCT + return NewBindableColumn(b, api.SQL_C_TYPE_DATE, int(unsafe.Sizeof(v))), nil + case api.SQL_TYPE_TIME: + var v api.SQL_TIME_STRUCT + return NewBindableColumn(b, api.SQL_C_TYPE_TIME, int(unsafe.Sizeof(v))), nil + case api.SQL_CHAR, api.SQL_VARCHAR, api.SQL_CLOB, api.SQL_DECFLOAT, api.SQL_DECIMAL: + return NewVariableWidthColumn(b, api.SQL_C_CHAR, size), nil + case api.SQL_WCHAR, api.SQL_WVARCHAR: + return NewVariableWidthColumn(b, api.SQL_C_WCHAR, size), nil + case api.SQL_BINARY, api.SQL_VARBINARY, api.SQL_BLOB: + return NewVariableWidthColumn(b, api.SQL_C_BINARY, size), nil + case api.SQL_LONGVARCHAR: + return NewVariableWidthColumn(b, api.SQL_C_CHAR, size), nil + case api.SQL_WLONGVARCHAR, api.SQL_SS_XML: + return NewVariableWidthColumn(b, api.SQL_C_WCHAR, size), nil + case api.SQL_LONGVARBINARY: + return NewVariableWidthColumn(b, api.SQL_C_BINARY, 0), nil + case api.SQL_DBCLOB: + return NewVariableWidthColumn(b, api.SQL_C_DBCHAR, size), nil + case api.SQL_XML: + return NewVariableWidthColumn(b, api.SQL_C_BINARY, 31457280), nil + default: + return nil, fmt.Errorf("unsupported column type %d", sqltype) + } + panic("unreachable") +} + +// BaseColumn implements common column functionality. +type BaseColumn struct { + name string + CType api.SQLSMALLINT + SType api.SQLSMALLINT +} + +func (c *BaseColumn) Name() string { + return c.name +} + +func (c *BaseColumn) TypeScan() reflect.Type { + trc.Trace1("column.go: TypeScan()") + + //TODO(Akhil):This will return the golang type of a variable + switch c.CType { + case api.SQL_C_BIT: + return reflect.TypeOf(false) + case api.SQL_C_LONG: + return reflect.TypeOf(int32(0)) + case api.SQL_C_SBIGINT: + return reflect.TypeOf(int64(0)) + case api.SQL_C_DOUBLE: + return reflect.TypeOf(float64(0.0)) + case api.SQL_C_CHAR, api.SQL_C_WCHAR: + if c.SType == api.SQL_DECFLOAT { + return reflect.TypeOf(float64(0.0)) + } + return reflect.TypeOf(string("")) + case api.SQL_C_TYPE_DATE, api.SQL_C_TYPE_TIME, api.SQL_C_TYPE_TIMESTAMP: + return reflect.TypeOf(time.Time{}) + case api.SQL_C_BINARY: + return reflect.TypeOf([]byte(nil)) + default: + return reflect.TypeOf(new(interface{})) + } + return reflect.TypeOf(new(interface{})) +} + +func (c *BaseColumn) Value(buf []byte) (driver.Value, error) { + trc.Trace1("column.go: Value()") + + var p unsafe.Pointer + if len(buf) > 0 { + p = unsafe.Pointer(&buf[0]) + } + switch c.CType { + case api.SQL_C_BIT: + return buf[0] != 0, nil + case api.SQL_C_LONG: + return *((*int32)(p)), nil + case api.SQL_C_SBIGINT: + return *((*int64)(p)), nil + case api.SQL_C_DOUBLE: + return *((*float64)(p)), nil + case api.SQL_C_CHAR: + if c.SType == api.SQL_DECIMAL { + return bytes.Replace(buf, []byte(","), []byte("."), 1), nil + } + return buf, nil + case api.SQL_C_WCHAR: + if p == nil { + return nil, nil + } + s := (*[1 << 20]uint16)(p)[:len(buf)/2] + return utf16toutf8(s), nil + case api.SQL_C_DBCHAR: + if p == nil { + return nil, nil + } + s := (*[1 << 20]uint8)(p)[:len(buf)] + return removeNulls(s), nil + case api.SQL_C_TYPE_TIMESTAMP: + t := (*api.SQL_TIMESTAMP_STRUCT)(p) + r := time.Date(int(t.Year), time.Month(t.Month), int(t.Day), + int(t.Hour), int(t.Minute), int(t.Second), int(t.Fraction), + time.Local) + return r, nil + case api.SQL_C_TYPE_DATE: + t := (*api.SQL_DATE_STRUCT)(p) + r := time.Date(int(t.Year), time.Month(t.Month), int(t.Day), + 0, 0, 0, 0, time.Local) + return r, nil + case api.SQL_C_TYPE_TIME: + t := (*api.SQL_TIME_STRUCT)(p) + r := time.Date(1, 1, 1, + int(t.Hour), + int(t.Minute), + int(t.Second), + 0, + time.Local) + return r, nil + case api.SQL_C_BINARY: + return buf, nil + } + return nil, fmt.Errorf("unsupported column ctype %d", c.CType) +} + +// BindableColumn allows access to columns that can have their buffers +// bound. Once bound at start, they are written to by odbc driver every +// time it fetches new row. This saves on syscall and, perhaps, some +// buffer copying. BindableColumn can be left unbound, then it behaves +// like NonBindableColumn when user reads data from it. +type BindableColumn struct { + *BaseColumn + IsBound bool + IsVariableWidth bool + Size int + Len BufferLen + Buffer []byte + smallBuf [8]byte // small inline memory buffer, so we do not need allocate external memory all the time +} + +func NewBindableColumn(b *BaseColumn, ctype api.SQLSMALLINT, bufSize int) *BindableColumn { + trc.Trace1("column.go: NewBindableColumn() - ENTRY") + trc.Trace1(fmt.Sprintf("bufSize = %d", bufSize)) + + b.CType = ctype + c := &BindableColumn{BaseColumn: b, Size: bufSize} + if c.Size <= len(c.smallBuf) { + // use inline buffer + c.Buffer = c.smallBuf[:c.Size] + } else { + c.Buffer = make([]byte, c.Size) + } + trc.Trace1("column.go: NewBindableColumn() - EXIT") + return c +} + +func NewVariableWidthColumn(b *BaseColumn, ctype api.SQLSMALLINT, colWidth api.SQLULEN) Column { + trc.Trace1("column.go: NewVariableWidthColumn() - ENTRY") + + if colWidth == 0 { + b.CType = ctype + return &NonBindableColumn{b} + } + l := int(colWidth) + switch ctype { + case api.SQL_C_WCHAR, api.SQL_C_DBCHAR: + l++ // room for null-termination character + l *= 2 // wchars take 2 bytes each + case api.SQL_C_CHAR: + if b.SType == api.SQL_DECIMAL { + l = l + 4 // adding 4 as decimal has '.' which takes 1 byte + } else { + l++ // room for null-termination character + l *= 2 //chars take 2 bytes each + } + case api.SQL_C_BINARY: + // nothing to do + default: + panic(fmt.Errorf("do not know how wide column of ctype %d is", ctype)) + } + c := NewBindableColumn(b, ctype, l) + c.IsVariableWidth = true + trc.Trace1("column.go: NewVariableWidthColumn() - EXIT") + return c +} + +func (c *BindableColumn) Bind(h api.SQLHSTMT, idx int) (bool, error) { + trc.Trace1("column.go: Bind() - ENTRY") + trc.Trace1(fmt.Sprintf("idx = %d", idx)) + + ret := c.Len.Bind(h, idx, c.CType, c.Buffer) + if IsError(ret) { + return false, NewError("SQLBindCol", h) + } + c.IsBound = true + trc.Trace1("column.go: Bind() - EXIT") + return true, nil +} + +func (c *BindableColumn) Value(h api.SQLHSTMT, idx int) (driver.Value, error) { + trc.Trace1("column.go: Value() - ENTRY") + trc.Trace1(fmt.Sprintf("idx = %d", idx)) + + if !c.IsBound { + ret := c.Len.GetData(h, idx, c.CType, c.Buffer) + if IsError(ret) { + return nil, NewError("SQLGetData", h) + } + } + if c.Len.IsNull() { + // is NULL + return nil, nil + } + if !c.IsVariableWidth && int(c.Len) != c.Size { + panic(fmt.Errorf("wrong column #%d length %d returned, %d expected", idx, c.Len, c.Size)) + } + // check buffer len + bufferLen := int(c.Len) + if len(c.Buffer) < bufferLen { + bufferLen = len(c.Buffer) + } + trc.Trace1("column.go: Value() - EXIT") + return c.BaseColumn.Value(c.Buffer[:bufferLen]) +} + +// NonBindableColumn provide access to columns, that can't be bound. +// These are of character or binary type, and, usually, there is no +// limit for their width. +type NonBindableColumn struct { + *BaseColumn +} + +func (c *NonBindableColumn) Bind(h api.SQLHSTMT, idx int) (bool, error) { + return false, nil +} + +func (c *NonBindableColumn) Value(h api.SQLHSTMT, idx int) (driver.Value, error) { + var l BufferLen + var total []byte + b := make([]byte, 1024) + trc.Trace1("column.go: Value() - ENTRY") +loop: + for { + ret := l.GetData(h, idx, c.CType, b) + switch ret { + case api.SQL_SUCCESS: + if l.IsNull() { + // is NULL + return nil, nil + } + total = append(total, b[:l]...) + break loop + case api.SQL_SUCCESS_WITH_INFO: + err := NewError("SQLGetData", h).(*Error) + if len(err.Diag) > 0 && err.Diag[0].State != "01004" { + return nil, err + } + i := len(b) + switch c.CType { + case api.SQL_C_WCHAR, api.SQL_C_DBCHAR: + i -= 2 // remove wchar (2 bytes) null-termination character + case api.SQL_C_CHAR: + i-- // remove null-termination character + } + total = append(total, b[:i]...) + if l != api.SQL_NO_TOTAL { + // odbc gives us a hint about remaining data, + // lets get it in one go. + n := int(l) // total bytes for our data + n -= i // subtract already received + n += 2 // room for biggest (wchar) null-terminator + if len(b) < n { + b = make([]byte, n) + } + } + default: + return nil, NewError("SQLGetData", h) + } + } + trc.Trace1("column.go: Value() - EXIT") + return c.BaseColumn.Value(total) +} diff --git a/vendor/github.com/ibmdb/go_ibm_db/conn.go b/vendor/github.com/ibmdb/go_ibm_db/conn.go new file mode 100644 index 00000000..bfae54f6 --- /dev/null +++ b/vendor/github.com/ibmdb/go_ibm_db/conn.go @@ -0,0 +1,103 @@ +// Copyright 2024 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package go_ibm_db + +import ( + "database/sql/driver" + "runtime" + "unsafe" + "fmt" + "github.com/ibmdb/go_ibm_db/api" + trc "github.com/ibmdb/go_ibm_db/log2" +) + +type Conn struct { + h api.SQLHDBC + tx *Tx +} + +func (d *Driver) Open(dsn string) (driver.Conn, error) { + trc.Trace1("conn.go: Open() - ENTRY") + trc.Trace1(fmt.Sprintf("dsn = %s", dsn)) + + var out api.SQLHANDLE + ret := api.SQLAllocHandle(api.SQL_HANDLE_DBC, api.SQLHANDLE(d.h), &out) + if IsError(ret) { + return nil, NewError("SQLAllocHandle", d.h) + } + h := api.SQLHDBC(out) + drv.Stats.updateHandleCount(api.SQL_HANDLE_DBC, 1) + + b := api.StringToUTF16(dsn) + if runtime.GOOS == "zos" { + ret = api.SQLDriverConnect(h, 0, + (*api.SQLWCHAR)(unsafe.Pointer(&b[0])), api.SQLSMALLINT(2*len(b)), // odbc api on zos doesn't handle null terminated strings, the exact size is passed + nil, 0, nil, api.SQL_DRIVER_NOPROMPT) + } else { + ret = api.SQLDriverConnect(h, 0, + (*api.SQLWCHAR)(unsafe.Pointer(&b[0])), api.SQLSMALLINT(len(b)), + nil, 0, nil, api.SQL_DRIVER_NOPROMPT) + } + if IsError(ret) { + defer releaseHandle(h) + return nil, NewError("SQLDriverConnect", h) + } + trc.Trace1("conn.go: Open() - EXIT") + return &Conn{h: h}, nil +} + +func (c *Conn) Close() error { + trc.Trace1("conn.go: Close() - ENTRY") + + ret := api.SQLDisconnect(c.h) + if IsError(ret) { + return NewError("SQLDisconnect", c.h) + } + h := c.h + c.h = api.SQLHDBC(api.SQL_NULL_HDBC) + trc.Trace1("conn.go: Close() - EXIT") + return releaseHandle(h) +} + +//Query method executes the statement with out prepare if no args provided, and a driver.ErrSkip otherwise (handled by sql.go to execute usual preparedStmt) +func (c *Conn) Query(query string, args []driver.Value) (driver.Rows, error) { + trc.Trace1("conn.go: Query() - ENTRY") + trc.Trace1(fmt.Sprintf("query = %s", query)) + + if len(args) > 0 { + // Not implemented for queries with parameters + return nil, driver.ErrSkip + } + var out api.SQLHANDLE + var os *ODBCStmt + ret := api.SQLAllocHandle(api.SQL_HANDLE_STMT, api.SQLHANDLE(c.h), &out) + if IsError(ret) { + return nil, NewError("SQLAllocHandle", c.h) + } + h := api.SQLHSTMT(out) + drv.Stats.updateHandleCount(api.SQL_HANDLE_STMT, 1) + b := api.StringToUTF16(query) + ret = api.SQLExecDirect(h, + (*api.SQLWCHAR)(unsafe.Pointer(&b[0])), api.SQL_NTS) + if IsError(ret) { + defer releaseHandle(h) + return nil, NewError("SQLExecDirectW", h) + } + ps, err := ExtractParameters(h) + if err != nil { + defer releaseHandle(h) + return nil, err + } + os = &ODBCStmt{ + h: h, + Parameters: ps, + usedByRows: true} + err = os.BindColumns() + if err != nil { + return nil, err + } + trc.Trace1("conn.go: Query() - EXIT") + return &Rows{os: os}, nil +} diff --git a/vendor/github.com/ibmdb/go_ibm_db/database.go b/vendor/github.com/ibmdb/go_ibm_db/database.go new file mode 100644 index 00000000..d8de26b7 --- /dev/null +++ b/vendor/github.com/ibmdb/go_ibm_db/database.go @@ -0,0 +1,137 @@ +package go_ibm_db + +import ( + "fmt" + "strings" + "unsafe" + + "github.com/ibmdb/go_ibm_db/api" + trc "github.com/ibmdb/go_ibm_db/log2" +) + +// CreateDb function will take the db name and user details as parameters +// and create the database. +func CreateDb(dbname string, connStr string, options ...string) (bool, error) { + trc.Trace1("database.go: CreateDb() - ENTRY") + trc.Trace1(fmt.Sprintf("dbname=%s, connStr=%s", dbname, connStr)) + + if dbname == "" { + trc.Trace1("Error: Database name cannot be empty") + trc.Trace1("database.go: CreateDb() - EXIT") + return false, fmt.Errorf("Database name cannot be empty") + } + var codeset, mode string + count := len(options) + if count > 0 { + for i := 0; i < count; i++ { + opt := strings.Split(options[i], "=") + if opt[0] == "codeset" { + codeset = opt[1] + } else if opt[0] == "mode" { + mode = opt[1] + } else { + return false, fmt.Errorf("not a valid parameter") + } + } + } + connStr = connStr + ";" + "ATTACH=true" + trc.Trace1("database.go: CreateDb() - EXIT") + return createDatabase(dbname, connStr, codeset, mode) +} + +func createDatabase(dbname string, connStr string, codeset string, mode string) (bool, error) { + trc.Trace1("database.go: createDatabase() - ENTRY") + trc.Trace1(fmt.Sprintf("dbname=%s, connStr=%s, codeset=%s, mode=%s", dbname, connStr, codeset, mode)) + var out api.SQLHANDLE + in := api.SQLHANDLE(api.SQL_NULL_HANDLE) + bufDBN := api.StringToUTF16(dbname) + bufCS := api.StringToUTF16(connStr) + bufC := api.StringToUTF16(codeset) + bufM := api.StringToUTF16(mode) + + ret := api.SQLAllocHandle(api.SQL_HANDLE_ENV, in, &out) + if IsError(ret) { + return false, NewError("SQLAllocHandle", api.SQLHENV(in)) + } + drvH := api.SQLHENV(out) + ret = api.SQLAllocHandle(api.SQL_HANDLE_DBC, api.SQLHANDLE(drvH), &out) + if IsError(ret) { + defer releaseHandle(drvH) + return false, NewError("SQLAllocHandle", drvH) + } + hdbc := api.SQLHDBC(out) + ret = api.SQLDriverConnect(hdbc, 0, + (*api.SQLWCHAR)(unsafe.Pointer(&bufCS[0])), api.SQLSMALLINT(len(bufCS)), + nil, 0, nil, api.SQL_DRIVER_NOPROMPT) + if IsError(ret) { + defer releaseHandle(hdbc) + return false, NewError("SQLDriverConnect", hdbc) + } + if codeset == "" && mode == "" { + ret = api.SQLCreateDb(hdbc, (*api.SQLWCHAR)(unsafe.Pointer(&bufDBN[0])), api.SQLINTEGER(len(bufDBN)), nil, 0, nil, 0) + } else if codeset == "" { + ret = api.SQLCreateDb(hdbc, (*api.SQLWCHAR)(unsafe.Pointer(&bufDBN[0])), api.SQLINTEGER(len(bufDBN)), nil, 0, (*api.SQLWCHAR)(unsafe.Pointer(&bufM[0])), api.SQLINTEGER(len(bufM))) + } else if mode == "" { + ret = api.SQLCreateDb(hdbc, (*api.SQLWCHAR)(unsafe.Pointer(&bufDBN[0])), api.SQLINTEGER(len(bufDBN)), (*api.SQLWCHAR)(unsafe.Pointer(&bufC[0])), api.SQLINTEGER(len(bufC)), nil, 0) + } else { + ret = api.SQLCreateDb(hdbc, (*api.SQLWCHAR)(unsafe.Pointer(&bufDBN[0])), api.SQLINTEGER(len(bufDBN)), (*api.SQLWCHAR)(unsafe.Pointer(&bufC[0])), api.SQLINTEGER(len(bufC)), (*api.SQLWCHAR)(unsafe.Pointer(&bufM[0])), api.SQLINTEGER(len(bufM))) + } + if IsError(ret) { + defer releaseHandle(hdbc) + return false, NewError("SQLCreateDb", hdbc) + } + defer releaseHandle(hdbc) + + trc.Trace1("database.go: createDatabase() - EXIT") + return true, nil +} + +// DropDb function will take the db name and user details as parameters +// and drop the database. +func DropDb(dbname string, connStr string) (bool, error) { + trc.Trace1("database.go: DropDb() - ENTRY") + trc.Trace1(fmt.Sprintf("dbname=%s, connStr=%s", dbname, connStr)) + + if dbname == "" { + return false, fmt.Errorf("Database name cannot be empty") + } + connStr = connStr + ";" + "ATTACH=true" + trc.Trace1("database.go: DropDb() - EXIT") + return dropDatabase(dbname, connStr) +} + +func dropDatabase(dbname string, connStr string) (bool, error) { + trc.Trace1("database.go: dropDatabase() - ENTRY") + trc.Trace1(fmt.Sprintf("dbname=%s, connStr=%s", dbname, connStr)) + + var out api.SQLHANDLE + in := api.SQLHANDLE(api.SQL_NULL_HANDLE) + bufDBN := api.StringToUTF16(dbname) + bufCS := api.StringToUTF16(connStr) + + ret := api.SQLAllocHandle(api.SQL_HANDLE_ENV, in, &out) + if IsError(ret) { + return false, NewError("SQLAllocHandle", api.SQLHENV(in)) + } + drvH := api.SQLHENV(out) + ret = api.SQLAllocHandle(api.SQL_HANDLE_DBC, api.SQLHANDLE(drvH), &out) + if IsError(ret) { + defer releaseHandle(drvH) + return false, NewError("SQLAllocHandle", drvH) + } + hdbc := api.SQLHDBC(out) + ret = api.SQLDriverConnect(hdbc, 0, + (*api.SQLWCHAR)(unsafe.Pointer(&bufCS[0])), api.SQLSMALLINT(len(bufCS)), + nil, 0, nil, api.SQL_DRIVER_NOPROMPT) + if IsError(ret) { + defer releaseHandle(hdbc) + return false, NewError("SQLDriverConnect", hdbc) + } + ret = api.SQLDropDb(hdbc, (*api.SQLWCHAR)(unsafe.Pointer(&bufDBN[0])), api.SQLINTEGER(len(bufDBN))) + if IsError(ret) { + defer releaseHandle(hdbc) + return false, NewError("SQLDropDb", hdbc) + } + defer releaseHandle(hdbc) + return true, nil +} diff --git a/vendor/github.com/ibmdb/go_ibm_db/driver.go b/vendor/github.com/ibmdb/go_ibm_db/driver.go new file mode 100644 index 00000000..7f90b8ad --- /dev/null +++ b/vendor/github.com/ibmdb/go_ibm_db/driver.go @@ -0,0 +1,97 @@ +// Copyright 2012 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// Package odbc implements database/sql driver to access data via odbc interface. +// +package go_ibm_db + +import ( + "database/sql" + "fmt" + "flag" + "os" + "github.com/ibmdb/go_ibm_db/api" + trc "github.com/ibmdb/go_ibm_db/log2" + "strings" +) + +var drv Driver + +type Driver struct { + Stats + h api.SQLHENV // environment handle +} + +func initDriver() error { + trc.Trace1("driver.go:InitDriver() - ENTRY") + + //Allocate environment handle + var out api.SQLHANDLE + in := api.SQLHANDLE(api.SQL_NULL_HANDLE) + ret := api.SQLAllocHandle(api.SQL_HANDLE_ENV, in, &out) + if IsError(ret) { + return NewError("SQLAllocHandle", api.SQLHENV(in)) + } + drv.h = api.SQLHENV(out) + drv.Stats.updateHandleCount(api.SQL_HANDLE_ENV, 1) + + // will use ODBC v3 + ret = api.SQLSetEnvUIntPtrAttr(drv.h, api.SQL_ATTR_ODBC_VERSION, + api.SQL_OV_ODBC3, 0) + if IsError(ret) { + defer releaseHandle(drv.h) + return NewError("SQLSetEnvAttr ODBC v3", drv.h) + } + + trc.Trace1("driver.go:InitDriver() - EXIT") + return nil +} + +func (d *Driver) Close() error { + trc.Trace1("driver.go: Close() - ENTRY") + + // TODO(brainman): who will call (*Driver).Close (to dispose all opened handles)? + h := d.h + d.h = api.SQLHENV(api.SQL_NULL_HENV) + + trc.Trace1("driver.go: Close() - EXIT") + return releaseHandle(h) +} + +func init() { + var cmdStr string = "" + + for e:=0; e 2 { + flag.Parse() + } + trc.GetPath(*wordPtr, len(os.Args)) + } + + + trc.Trace1("driver.go:init() - ENTRY") + + // Recover from panic to avoid stop an application when can't get the db2 cli + defer func() { + if err := recover(); err != nil { + fmt.Println(fmt.Sprintf("%s\nThe go_ibm_db driver cannot be registered", err)) + } + }() + + err := initDriver() + if err != nil { + panic(err) + } + //go's to databse/sql/sql.go 43 line + sql.Register("go_ibm_db", &drv) + + trc.Trace1("driver.go:init() - EXIT") +} diff --git a/vendor/github.com/ibmdb/go_ibm_db/error.go b/vendor/github.com/ibmdb/go_ibm_db/error.go new file mode 100644 index 00000000..ab54c2af --- /dev/null +++ b/vendor/github.com/ibmdb/go_ibm_db/error.go @@ -0,0 +1,99 @@ +// Copyright 2024 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package go_ibm_db + +import ( + "database/sql/driver" + "fmt" + "runtime" + "strings" + "unsafe" + + "github.com/ibmdb/go_ibm_db/api" + trc "github.com/ibmdb/go_ibm_db/log2" +) + +func IsError(ret api.SQLRETURN) bool { + trc.Trace1("error.go: IsError() - ENTRY") + if ret == api.SQL_SUCCESS { + trc.Trace1("api.SQL_SUCCESS") + } else if ret == api.SQL_SUCCESS_WITH_INFO { + trc.Trace1("api.SQL_SUCCESS_WITH_INFO") + } + trc.Trace1("error.go: IsError() - EXIT") + return !(ret == api.SQL_SUCCESS || ret == api.SQL_SUCCESS_WITH_INFO) +} + +type DiagRecord struct { + State string + NativeError int + Message string +} + +func (r *DiagRecord) String() string { + return fmt.Sprintf("{%s} %s", r.State, r.Message) +} + +type Error struct { + APIName string + Diag []DiagRecord +} + +func (e *Error) Error() string { + trc.Trace1("error.go: Error() - ENTRY") + ss := make([]string, len(e.Diag)) + for i, r := range e.Diag { + ss[i] = r.String() + } + trc.Trace1(fmt.Sprintf("%s : %s", e.APIName, ss)) + trc.Trace1("error.go: Error() - EXIT") + return e.APIName + ": " + strings.Join(ss, "\n") +} + +func NewError(apiName string, handle interface{}) error { + trc.Trace1("error.go: NewError() - ENTRY") + trc.Trace1(fmt.Sprintf("apiName=%s",apiName)) + + var ret api.SQLRETURN + h, ht := ToHandleAndType(handle) + err := &Error{APIName: apiName} + var ne api.SQLINTEGER + state := make([]uint16, 6) + msg := make([]uint16, api.SQL_MAX_MESSAGE_LENGTH) + for i := 1; ; i++ { + if runtime.GOOS == "zos" { + ret = api.SQLGetDiagRec(ht, h, api.SQLSMALLINT(i), + (*api.SQLWCHAR)(unsafe.Pointer(&state[0])), &ne, + (*api.SQLWCHAR)(unsafe.Pointer(&msg[0])), + api.SQLSMALLINT(2*len(msg)), nil) // odbc api on zos doesn't handle null terminated strings, the exact size is passed + } else { + ret = api.SQLGetDiagRec(ht, h, api.SQLSMALLINT(i), + (*api.SQLWCHAR)(unsafe.Pointer(&state[0])), &ne, + (*api.SQLWCHAR)(unsafe.Pointer(&msg[0])), + api.SQLSMALLINT(len(msg)), nil) + } + if ret == api.SQL_NO_DATA { + break + } + if IsError(ret) { + trc.Trace1(fmt.Sprintf("SQLGetDiagRec failed: ret=%d", ret)) + panic(fmt.Errorf("SQLGetDiagRec failed: ret=%d", ret)) + } + r := DiagRecord{ + State: api.UTF16ToString(state), + NativeError: int(ne), + Message: api.UTF16ToString(msg), + } + if strings.Contains(r.Message, "CLI0106E") || + strings.Contains(r.Message, "CLI0107E") || + strings.Contains(r.Message, "CLI0108E") { + return driver.ErrBadConn + } + err.Diag = append(err.Diag, r) + } + trc.Trace1(fmt.Sprintf("Error: %s", err)) + trc.Trace1("error.go: NewError() - EXIT") + return err +} diff --git a/vendor/github.com/ibmdb/go_ibm_db/handle.go b/vendor/github.com/ibmdb/go_ibm_db/handle.go new file mode 100644 index 00000000..1eb67d11 --- /dev/null +++ b/vendor/github.com/ibmdb/go_ibm_db/handle.go @@ -0,0 +1,52 @@ +// Copyright 2012 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package go_ibm_db + +import ( + "fmt" + "github.com/ibmdb/go_ibm_db/api" + trc "github.com/ibmdb/go_ibm_db/log2" +) + +func ToHandleAndType(handle interface{}) (h api.SQLHANDLE, ht api.SQLSMALLINT) { + trc.Trace1("handle.go: ToHandleAndType() - ENTRY") + + switch v := handle.(type) { + case api.SQLHENV: + if v == api.SQLHENV(api.SQL_NULL_HANDLE) { + ht = 0 + } else { + ht = api.SQL_HANDLE_ENV + } + h = api.SQLHANDLE(v) + case api.SQLHDBC: + ht = api.SQL_HANDLE_DBC + h = api.SQLHANDLE(v) + case api.SQLHSTMT: + ht = api.SQL_HANDLE_STMT + h = api.SQLHANDLE(v) + default: + panic(fmt.Errorf("unexpected handle type %T", v)) + } + trc.Trace1("handle.go: ToHandleAndType() - EXIT") + return h, ht +} + +func releaseHandle(handle interface{}) error { + trc.Trace1("handle.go: releaseHandle() - ENTRY") + + h, ht := ToHandleAndType(handle) + ret := api.SQLFreeHandle(ht, h) + if ret == api.SQL_INVALID_HANDLE { + return fmt.Errorf("SQLFreeHandle(%d, %d) returns SQL_INVALID_HANDLE", ht, h) + } + if IsError(ret) { + return NewError("SQLFreeHandle", handle) + } + drv.Stats.updateHandleCount(ht, -1) + + trc.Trace1("handle.go: releaseHandle() - EXIT") + return nil +} diff --git a/vendor/github.com/ibmdb/go_ibm_db/log2/logger1.go b/vendor/github.com/ibmdb/go_ibm_db/log2/logger1.go new file mode 100644 index 00000000..75b66cf5 --- /dev/null +++ b/vendor/github.com/ibmdb/go_ibm_db/log2/logger1.go @@ -0,0 +1,49 @@ +// Copyright 2012 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// Package odbc implements database/sql driver to access data via odbc interface. +package log2 + +import ( + "log" + "os" + "fmt" +) + +var globalvar string = "" +var globalArgsLen int = 0 + +func GetPath(filename string, argsLen int) { + //fmt.Println("filename = ", filename) + //fmt.Println("Args Length = ", argsLen) + + if _, err := os.Stat(filename); err == nil { + //fmt.Println("File exits\n") + e := os.Remove(filename) + if e != nil { + fmt.Println("Problem in removing existing log file") + } + } + + globalvar = filename + globalArgsLen = argsLen + +} + +func Trace1(msg1 string) { + if globalvar != "" { + //file, errlog := os.OpenFile("C:\\temp\\testlogs2.txt", os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0666) + file, errlog := os.OpenFile(globalvar, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0666) + if errlog != nil { + log.Fatal(errlog) + } + log.SetOutput(file) + log.Println(msg1) + } else if globalArgsLen > 1 { + log.SetOutput(os.Stdout) + log.Println(msg1) + } + +} + diff --git a/vendor/github.com/ibmdb/go_ibm_db/odbcstmt.go b/vendor/github.com/ibmdb/go_ibm_db/odbcstmt.go new file mode 100644 index 00000000..9b976fb5 --- /dev/null +++ b/vendor/github.com/ibmdb/go_ibm_db/odbcstmt.go @@ -0,0 +1,260 @@ +// Copyright 2012 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package go_ibm_db + +import ( + "database/sql/driver" + "errors" + "fmt" + "sync" + "time" + "unsafe" + + "github.com/ibmdb/go_ibm_db/api" + trc "github.com/ibmdb/go_ibm_db/log2" +) + +// TODO(brainman): see if I could use SQLExecDirect anywhere + +type ODBCStmt struct { + h api.SQLHSTMT + Parameters []Parameter + Cols []Column + // locking/lifetime + mu sync.Mutex + usedByStmt bool + usedByRows bool +} + +func (c *Conn) PrepareODBCStmt(query string) (*ODBCStmt, error) { + trc.Trace1("odbcstmt.go: PrepareODBCStmt() - ENTRY") + trc.Trace1(fmt.Sprintf("query=%s", query)) + + var out api.SQLHANDLE + ret := api.SQLAllocHandle(api.SQL_HANDLE_STMT, api.SQLHANDLE(c.h), &out) + if IsError(ret) { + return nil, NewError("SQLAllocHandle", c.h) + } + h := api.SQLHSTMT(out) + drv.Stats.updateHandleCount(api.SQL_HANDLE_STMT, 1) + b := api.StringToUTF16(query) + ret = api.SQLPrepare(h, + (*api.SQLWCHAR)(unsafe.Pointer(&b[0])), api.SQL_NTS) + if IsError(ret) { + defer releaseHandle(h) + return nil, NewError("SQLPrepare", h) + } + ps, err := ExtractParameters(h) + if err != nil { + defer releaseHandle(h) + return nil, err + } + + trc.Trace1("odbcstmt.go: PrepareODBCStmt() - EXIT") + return &ODBCStmt{ + h: h, + Parameters: ps, + usedByStmt: true, + }, nil +} + +func (s *ODBCStmt) closeByStmt() error { + trc.Trace1("odbcstmt.go: closeByStmt() - ENTRY") + + s.mu.Lock() + defer s.mu.Unlock() + if s.usedByStmt { + defer func() { s.usedByStmt = false }() + if !s.usedByRows { + return s.releaseHandle() + } + } + trc.Trace1("odbcstmt.go: closeByStmt() - EXIT") + return nil +} + +func (s *ODBCStmt) closeByRows() error { + trc.Trace1("odbcstmt.go: closeByRows()") + + s.mu.Lock() + defer s.mu.Unlock() + if s.usedByRows { + defer func() { s.usedByRows = false }() + if s.usedByStmt { + ret := api.SQLCloseCursor(s.h) + if IsError(ret) { + return NewError("SQLCloseCursor", s.h) + } + return nil + } else { + return s.releaseHandle() + } + } + return nil +} + +func (s *ODBCStmt) releaseHandle() error { + trc.Trace1("odbcstmt.go: releaseHandle()") + + h := s.h + s.h = api.SQLHSTMT(api.SQL_NULL_HSTMT) + return releaseHandle(h) +} + +var testingIssue5 bool // used during tests + +func (s *ODBCStmt) Exec(args []driver.Value) error { + trc.Trace1("odbcstmt.go: Exec() - ENTRY") + + ArrayCheck := 0 + ArrayLength := 0 + if len(args) != len(s.Parameters) { + return fmt.Errorf("wrong number of arguments %d, %d expected", len(args), len(s.Parameters)) + } + for i, a := range args { + // this could be done in 2 steps: + // 1) bind vars right after prepare; + // 2) set their (vars) values here; + // but rebinding parameters for every new parameter value + // should be efficient enough for our purpose. + err := s.Parameters[i].BindValue(s.h, i, a) + if err != nil { + return err + } + } + if testingIssue5 { + time.Sleep(10 * time.Microsecond) + } + + for _, a := range args { + if ArrayLength == 0 { + switch d := a.(type) { + case []int64: + ArrayLength = len(d) + ArrayCheck = 1 + case []string: + ArrayLength = len(d) + ArrayCheck = 1 + case []bool: + ArrayLength = len(d) + ArrayCheck = 1 + case []float64: + ArrayLength = len(d) + ArrayCheck = 1 + case []time.Time: + ArrayLength = len(d) + ArrayCheck = 1 + } + } else { + switch d := a.(type) { + case []int64: + if len(d) == ArrayLength { + ArrayLength = len(d) + ArrayCheck = 1 + } else { + ArrayCheck = 0 + return fmt.Errorf("Parameter's array value length should be same") + } + case []string: + if len(d) == ArrayLength { + ArrayLength = len(d) + ArrayCheck = 1 + } else { + ArrayCheck = 0 + return fmt.Errorf("Parameter's array value length should be same") + } + case []bool: + if len(d) == ArrayLength { + ArrayLength = len(d) + ArrayCheck = 1 + } else { + ArrayCheck = 0 + return fmt.Errorf("Parameter's array value length should be same") + } + case []float64: + if len(d) == ArrayLength { + ArrayLength = len(d) + ArrayCheck = 1 + } else { + ArrayCheck = 0 + return fmt.Errorf("Parameter's array value length should be same") + } + case []time.Time: + if len(d) == ArrayLength { + ArrayLength = len(d) + ArrayCheck = 1 + } else { + ArrayCheck = 0 + return fmt.Errorf("Parameter's array value length should be same") + } + } + } + } + + if ArrayCheck == 1 { + ret := api.SQLSetStmtAttr(s.h, api.SQL_ATTR_PARAMSET_SIZE, + (api.SQLPOINTER)(uintptr(ArrayLength)), api.SQL_IS_INTEGER) + if IsError(ret) { + return NewError("SQLSetStmtAttr", s.h) + } + } + + ret := api.SQLExecute(s.h) + if ret == api.SQL_NO_DATA { + // success but no data to report + return nil + } + if IsError(ret) { + return NewError("SQLExecute", s.h) + } + for _, p := range s.Parameters { + for _, o := range p.Outs { + if err := o.ConvertAssign(); err != nil { + return err + } + } + } + trc.Trace1("odbcstmt.go: Exec() - EXIT") + return nil +} + +func (s *ODBCStmt) BindColumns() error { + trc.Trace1("odbcstmt.go: BindColumns() - ENTRY") + + // count columns + var n api.SQLSMALLINT + ret := api.SQLNumResultCols(s.h, &n) + if IsError(ret) { + return NewError("SQLNumResultCols", s.h) + } + if n < 1 { + return errors.New("Query executed successfully but did not create a result set") + } + // fetch column descriptions + s.Cols = make([]Column, n) + binding := true + for i := range s.Cols { + c, err := NewColumn(s.h, i) + if err != nil { + return err + } + s.Cols[i] = c + // Once we found one non-bindable column, we will not bind the rest. + // http://www.easysoft.com/developer/languages/c/odbc-tutorial-fetching-results.html + // ... One common restriction is that SQLGetData may only be called on columns after the last bound column. ... + if !binding { + continue + } + bound, err := s.Cols[i].Bind(s.h, i) + if err != nil { + return err + } + if !bound { + binding = false + } + } + trc.Trace1("odbcstmt.go: BindColumns() - EXIT") + return nil +} diff --git a/vendor/github.com/ibmdb/go_ibm_db/param.go b/vendor/github.com/ibmdb/go_ibm_db/param.go new file mode 100644 index 00000000..542f4211 --- /dev/null +++ b/vendor/github.com/ibmdb/go_ibm_db/param.go @@ -0,0 +1,338 @@ +// Copyright 2012 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package go_ibm_db + +import ( + "database/sql" + "database/sql/driver" + "fmt" + "time" + "unsafe" + + "github.com/ibmdb/go_ibm_db/api" + trc "github.com/ibmdb/go_ibm_db/log2" +) + +type Parameter struct { + SQLType api.SQLSMALLINT + Decimal api.SQLSMALLINT + Size api.SQLULEN + isDescribed bool + // Following fields store data used later by SQLExecute. + // The fields keep data alive and away from gc. + Data interface{} + StrLen_or_IndPtr api.SQLLEN + Outs []*Out +} + +// StoreStrLen_or_IndPtr stores v into StrLen_or_IndPtr field of p +// and returns address of that field. +func (p *Parameter) StoreStrLen_or_IndPtr(v api.SQLLEN) *api.SQLLEN { + trc.Trace1("param.go: StoreStrLen_or_IndPtr()") + + p.StrLen_or_IndPtr = v + return &p.StrLen_or_IndPtr + +} + +func (p *Parameter) BindValue(h api.SQLHSTMT, idx int, v driver.Value) error { + // TODO(brainman): Reuse memory for previously bound values. If memory + // is reused, we, probably, do not need to call SQLBindParameter either. + trc.Trace1("param.go: BindValue() - ENTRY") + + var ctype, sqltype, decimal api.SQLSMALLINT + var size api.SQLULEN + var buflen api.SQLLEN + var plen *api.SQLLEN + var buf unsafe.Pointer + var iotype api.SQLSMALLINT = api.SQL_PARAM_INPUT + switch d := v.(type) { + case nil: + if p.SQLType == api.SQL_BLOB || p.SQLType == api.SQL_VARBINARY || p.SQLType == api.SQL_BINARY { + ctype = api.SQL_C_BINARY + sqltype = api.SQL_BINARY + } else { + ctype = api.SQL_C_WCHAR + sqltype = api.SQL_WCHAR + } + p.Data = nil + buf = nil + size = 1 + buflen = 0 + plen = p.StoreStrLen_or_IndPtr(api.SQL_NULL_DATA) + case string: + ctype = api.SQL_C_WCHAR + b := api.StringToUTF16(d) + p.Data = b + buf = unsafe.Pointer(&b[0]) + l := len(b) + l -= 1 // remove terminating 0 + size = api.SQLULEN(l) + if size < 1 { + // size cannot be less then 1 even for empty fields + size = 1 + } + l *= 2 // every char takes 2 bytes + buflen = api.SQLLEN(l) + plen = p.StoreStrLen_or_IndPtr(buflen) + if p.isDescribed { + // only so we can handle very long (>4000 chars) parameters + sqltype = p.SQLType + } else { + sqltype = api.SQL_WCHAR + } + // sqltype is SQL_DECIMAL set p.Decimal + if sqltype == api.SQL_DECIMAL { + decimal = p.Decimal + size = p.Size // SQL_DECIMAL this is the maximum decimal precision + } + case int64: + ctype = api.SQL_C_SBIGINT + p.Data = &d + buf = unsafe.Pointer(&d) + sqltype = api.SQL_BIGINT + size = 8 + case bool: + var b int + if d { + b = 1 + } + ctype = api.SQL_C_SBIGINT + p.Data = &b + buf = unsafe.Pointer(&b) + sqltype = api.SQL_BIGINT + size = 1 + case float64: + ctype = api.SQL_C_DOUBLE + p.Data = &d + buf = unsafe.Pointer(&d) + sqltype = api.SQL_DOUBLE + size = 8 + case time.Time: + ctype = api.SQL_C_TYPE_TIMESTAMP + y, m, day := d.Date() + b := api.SQL_TIMESTAMP_STRUCT{ + Year: api.SQLSMALLINT(y), + Month: api.SQLUSMALLINT(m), + Day: api.SQLUSMALLINT(day), + Hour: api.SQLUSMALLINT(d.Hour()), + Minute: api.SQLUSMALLINT(d.Minute()), + Second: api.SQLUSMALLINT(d.Second()), + Fraction: api.SQLUINTEGER(d.Nanosecond()), + } + p.Data = &b + buf = unsafe.Pointer(&b) + sqltype = api.SQL_TYPE_TIMESTAMP + if p.isDescribed && p.SQLType == api.SQL_TYPE_TIMESTAMP { + decimal = p.Decimal + } + if decimal <= 0 { + // represented as yyyy-mm-dd hh:mm:ss.fff format in ms sql server + decimal = 3 + } + size = 20 + api.SQLULEN(decimal) + case []byte: + ctype = api.SQL_C_BINARY + b := make([]byte, len(d)) + copy(b, d) + p.Data = b + if len(d) > 0 { + buf = unsafe.Pointer(&b[0]) + } + buflen = api.SQLLEN(len(b)) + plen = p.StoreStrLen_or_IndPtr(buflen) + size = api.SQLULEN(len(b)) + sqltype = api.SQL_BINARY + case sql.Out: + o, err := newOut(h, &d, idx) + if err != nil { + return err + } + iotype = o.inputOutputType + sqltype = o.sqltype + ctype = o.ctype + size = o.parameterSize + decimal = o.decimalDigits + b := o.data + if len(b) > 0 { + buf = unsafe.Pointer(&b[0]) + } + buflen = o.buflen + plen = o.plen + p.Outs = append(p.Outs, o) + case []int64: + ctype = api.SQL_C_SBIGINT + b := make([]int64, len(d)) + copy(b, d) + p.Data = b + buf = unsafe.Pointer(&b[0]) + buflen = api.SQLLEN(len(b)) + plen = p.StoreStrLen_or_IndPtr(buflen) + size = api.SQLULEN(len(b)) + sqltype = api.SQL_BIGINT + case []string: + ctype = api.SQL_C_WCHAR + maxlen := len(d[0]) + 1 + for i := 0; i < len(d); i++ { + if maxlen <= len(d[i]) { + maxlen = len(d[i]) + 1 + } + } + b := []uint16{} + for i := 0; i < len(d); i++ { + temp := api.StringToUTF16(d[i]) + if len(temp) < maxlen { + diff := maxlen - len(temp) + for i := 0; i < diff; i++ { + temp = append(temp, 0) + } + } + b = append(b, temp...) + } + l := maxlen + p.Data = b + buf = unsafe.Pointer(&b[0]) + size = api.SQLULEN(l) + if size < 1 { + // size cannot be less then 1 even for empty fields + size = 1 + } + l *= 2 // every char takes 2 bytes + buflen = api.SQLLEN(l) + plen = nil + if p.isDescribed { + // only so we can handle very long (>4000 chars) parameters + sqltype = p.SQLType + } else { + sqltype = api.SQL_WCHAR + } + case []bool: + b := make([]int64, len(d)) + for i := 0; i < len(d); i++ { + if d[i] { + b[i] = 1 + } + } + p.Data = b + ctype = api.SQL_C_SBIGINT + sqltype = api.SQL_BIGINT + size = api.SQLULEN(len(b)) + buf = unsafe.Pointer(&b[0]) + buflen = api.SQLLEN(len(b)) + plen = p.StoreStrLen_or_IndPtr(buflen) + case []float64: + ctype = api.SQL_C_DOUBLE + b := make([]float64, len(d)) + copy(b, d) + p.Data = b + buf = unsafe.Pointer(&b[0]) + buflen = api.SQLLEN(len(b)) + plen = p.StoreStrLen_or_IndPtr(buflen) + size = api.SQLULEN(len(b)) + sqltype = api.SQL_DOUBLE + case []time.Time: + ctype = api.SQL_C_TYPE_TIMESTAMP + b := make([]api.SQL_TIMESTAMP_STRUCT, len(d)) + for i := 0; i < len(d); i++ { + y, m, day := d[i].Date() + b[i] = api.SQL_TIMESTAMP_STRUCT{ + Year: api.SQLSMALLINT(y), + Month: api.SQLUSMALLINT(m), + Day: api.SQLUSMALLINT(day), + Hour: api.SQLUSMALLINT(d[i].Hour()), + Minute: api.SQLUSMALLINT(d[i].Minute()), + Second: api.SQLUSMALLINT(d[i].Second()), + Fraction: api.SQLUINTEGER(d[i].Nanosecond()), + } + } + p.Data = b + buf = unsafe.Pointer(&b[0]) + sqltype = api.SQL_TYPE_TIMESTAMP + if p.isDescribed && p.SQLType == api.SQL_TYPE_TIMESTAMP { + decimal = p.Decimal + } + if decimal <= 0 { + // represented as yyyy-mm-dd hh:mm:ss.fff format in ms sql server + decimal = 3 + } + size = 20 + api.SQLULEN(decimal) + default: + panic(fmt.Errorf("unsupported bind param type %T", v)) + } + ret := api.SQLBindParameter(h, api.SQLUSMALLINT(idx+1), + iotype, ctype, sqltype, size, decimal, + api.SQLPOINTER(buf), buflen, plen) + if IsError(ret) { + return NewError("SQLBindParameter", h) + } + + trc.Trace1("param.go: BindValue() - EXIT") + return nil +} + +// ExtractParameters will describe all the parameters +func ExtractParameters(h api.SQLHSTMT) ([]Parameter, error) { + // count parameters + trc.Trace1("param.go: ExtractParameters() - ENTRY") + + var n, nullable api.SQLSMALLINT + ret := api.SQLNumParams(h, &n) + if IsError(ret) { + return nil, NewError("SQLNumParams", h) + } + if n <= 0 { + // no parameters + trc.Trace1("param.go: ExtractParameters() - no parameters") + return nil, nil + } + ps := make([]Parameter, n) + //fetch param descriptions + for i := range ps { + p := &ps[i] + ret = api.SQLDescribeParam(h, api.SQLUSMALLINT(i+1), + &p.SQLType, &p.Size, &p.Decimal, &nullable) + if IsError(ret) { + // SQLDescribeParam is not implemented by freedts, + // it even fails for some statements on windows. + // Will try request without these descriptions + continue + } + p.isDescribed = true + } + trc.Trace1("param.go: ExtractParameters() - EXIT") + return ps, nil +} + +//SqltoCtype function will convert the sql type to c type +func SqltoCtype(sqltype api.SQLSMALLINT) api.SQLSMALLINT { + trc.Trace1("param.go: SqltoCtype()") + + switch sqltype { + case api.SQL_BIT: + return api.SQL_C_BIT + case api.SQL_TINYINT, api.SQL_SMALLINT, api.SQL_INTEGER: + return api.SQL_C_LONG + case api.SQL_BIGINT: + return api.SQL_C_SBIGINT + case api.SQL_NUMERIC, api.SQL_DECIMAL, api.SQL_FLOAT, api.SQL_REAL, api.SQL_DOUBLE: + return api.SQL_C_DOUBLE + case api.SQL_TYPE_TIMESTAMP: + return api.SQL_C_TYPE_TIMESTAMP + case api.SQL_TYPE_DATE: + return api.SQL_C_TYPE_DATE + case api.SQL_TYPE_TIME: + return api.SQL_C_TYPE_TIME + case api.SQL_CHAR, api.SQL_VARCHAR, api.SQL_CLOB, api.SQL_LONGVARCHAR: + return api.SQL_C_CHAR + case api.SQL_WCHAR, api.SQL_WVARCHAR, api.SQL_WLONGVARCHAR, api.SQL_SS_XML: + return api.SQL_C_WCHAR + case api.SQL_BINARY, api.SQL_VARBINARY, api.SQL_BLOB, api.SQL_LONGVARBINARY: + return api.SQL_C_BINARY + case api.SQL_DBCLOB: + return api.SQL_C_DBCHAR + default: + panic(fmt.Errorf("unsupported param type %v at sql.out", sqltype)) + } +} diff --git a/vendor/github.com/ibmdb/go_ibm_db/pooling.go b/vendor/github.com/ibmdb/go_ibm_db/pooling.go new file mode 100644 index 00000000..02f7b5f4 --- /dev/null +++ b/vendor/github.com/ibmdb/go_ibm_db/pooling.go @@ -0,0 +1,303 @@ +package go_ibm_db + +import ( + "database/sql" + "fmt" + "strconv" + "strings" + "time" + "sync" + trc "github.com/ibmdb/go_ibm_db/log2" +) + +//DBP struct type contains the timeout, dbinstance and connection string +type DBP struct { + sql.DB + con string + n time.Duration +} + +//Pool struct contais the about the pool like size, used and available connections +type Pool struct { + availablePool map[string][]*DBP + usedPool map[string][]*DBP + poolSize int + mu sync.Mutex +} + +var b *Pool +var connMaxLifetime, poolSize int +const defaultMaxIdleConns = 2 +const defaultConnMaxLifetime = 60 + +//Pconnect will return the pool instance +func Pconnect(poolSize string) *Pool { + trc.Trace1("pooling.go: Pconnect() - ENTRY") + trc.Trace1(fmt.Sprintf("poolSize=%s", poolSize)) + + var size int + count := len(poolSize) + if count > 0 { + opt := strings.Split(poolSize, "=") + if opt[0] == "PoolSize" { + size, _ = strconv.Atoi(opt[1]) + if size <= 0 { + size = defaultMaxIdleConns + } + } else { + fmt.Println("Not a valid parameter") + } + } else { + size = defaultMaxIdleConns + } + p := &Pool{ + availablePool: make(map[string][]*DBP), + usedPool: make(map[string][]*DBP), + poolSize: size, + } + b = p + + trc.Trace1("pooling.go: Pconnect() - EXIT") + return p +} + +//Psize sets the size of the pool idf value is passed +var pSize int + +//Open will check for the connection in the pool +//If not opens a new connection and stores in the pool +func (p *Pool) Open(connStr string, options ...string) *DBP { + trc.Trace1("pooling.go: Open() - ENTRY") + trc.Trace1(fmt.Sprintf("connStr=%s",connStr)) + + var Time time.Duration + count := len(options) + if count > 0 { + for i := 0; i < count; i++ { + opt := strings.Split(options[i], "=") + if opt[0] == "SetConnMaxLifetime" { + connMaxLifetime, _ = strconv.Atoi(opt[1]) + if connMaxLifetime <= 0 { + connMaxLifetime = defaultConnMaxLifetime + } + Time = time.Duration(connMaxLifetime) * time.Second + } else { + fmt.Println("Not a valid parameter") + } + } + } else { + Time = time.Duration(defaultConnMaxLifetime) * time.Second + } + if pSize < p.poolSize { + pSize = pSize + 1 + if val, ok := p.availablePool[connStr]; ok { + if len(val) > 1 { + p.mu.Lock() + dbpo := val[0] + copy(val[0:], val[1:]) + val[len(val)-1] = nil + val = val[:len(val)-1] + p.availablePool[connStr] = val + p.usedPool[connStr] = append(p.usedPool[connStr], dbpo) + dbpo.SetConnMaxLifetime(Time) + p.mu.Unlock() + return dbpo + } else { + p.mu.Lock() + dbpo := val[0] + p.usedPool[connStr] = append(p.usedPool[connStr], dbpo) + delete(p.availablePool, connStr) + dbpo.SetConnMaxLifetime(Time) + p.mu.Unlock() + return dbpo + } + } else { + db, err := sql.Open("go_ibm_db", connStr) + if err != nil { + return nil + } + dbi := &DBP{ + DB: *db, + con: connStr, + n: Time, + } + p.mu.Lock() + p.usedPool[connStr] = append(p.usedPool[connStr], dbi) + dbi.SetConnMaxLifetime(Time) + p.mu.Unlock() + return dbi + } + } else { + pSize = pSize + 1 + + for i := 0; i < connMaxLifetime; i++ { + if len(p.availablePool) <= 0 { + time.Sleep(3 * time.Second) + i = i + 2 + } else { + if val, ok := p.availablePool[connStr]; ok { + if len(val) > 1 { + p.mu.Lock() + dbpo := val[0] + copy(val[0:], val[1:]) + val[len(val)-1] = nil + val = val[:len(val)-1] + p.availablePool[connStr] = val + p.usedPool[connStr] = append(p.usedPool[connStr], dbpo) + dbpo.SetConnMaxLifetime(Time) + p.mu.Unlock() + return dbpo + } else { + dbpo := val[0] + return dbpo + } + } + } + } + fmt.Println("Connection timeout") + trc.Trace1("Connection timeout") + trc.Trace1("pooling.go: Open() - EXIT") + return nil + } + trc.Trace1("pooling.go: Open() - EXIT") + return nil +} + +func (p *Pool) Init(numConn int, connStr string) bool{ + trc.Trace1("pooling.go: Init() - ENTRY") + trc.Trace1(fmt.Sprintf("numConn=%d, connStr=%s", numConn, connStr)) + + var Time time.Duration + + if connMaxLifetime <= 0 { + Time = time.Duration(defaultConnMaxLifetime) * time.Second + } else { + Time = time.Duration(connMaxLifetime) * time.Second + } + + for i := 0; i < numConn; i++ { + db, err := sql.Open("go_ibm_db", connStr) + if err != nil { + trc.Trace1("pooling.go: Init() - return false") + return false + } + dbi := &DBP{ + DB: *db, + con: connStr, + n: Time, + } + p.mu.Lock() + p.availablePool[connStr] = append(p.availablePool[connStr], dbi) + dbi.SetConnMaxLifetime(Time) + p.mu.Unlock() + } + trc.Trace1("pooling.go: Init() - EXIT") + return true +} + +//Close will make the connection available for the next release +func (d *DBP) Close() { + trc.Trace1("pooling.go: Close() - ENTRY") + + pSize = pSize - 1 + var pos int + i := -1 + b.mu.Lock() + if valc, okc := b.usedPool[d.con]; okc { + if len(valc) > 1 { + for _, b := range valc { + i = i + 1 + if b == d { + pos = i + } + } + dbpc := valc[pos] + copy(valc[pos:], valc[pos+1:]) + valc[len(valc)-1] = nil + valc = valc[:len(valc)-1] + b.usedPool[d.con] = valc + b.availablePool[d.con] = append(b.availablePool[d.con], dbpc) + } else { + dbpc := valc[0] + b.availablePool[d.con] = append(b.availablePool[d.con], dbpc) + delete(b.usedPool, d.con) + } + go d.Timeout() + } else { + d.DB.Close() + } + b.mu.Unlock() + trc.Trace1("pooling.go: Close() - EXIT") +} + +//Timeout for closing the connection in pool +func (d *DBP) Timeout() { + trc.Trace1("pooling.go: Timeout() - ENTRY") + + var pos int + i := -1 + select { + case <-time.After(d.n): + b.mu.Lock() + if valt, okt := b.availablePool[d.con]; okt { + if len(valt) > 1 { + for _, b := range valt { + i = i + 1 + if b == d { + pos = i + } + } + dbpt := valt[pos] + copy(valt[pos:], valt[pos+1:]) + valt[len(valt)-1] = nil + valt = valt[:len(valt)-1] + b.availablePool[d.con] = valt + dbpt.DB.Close() + } else { + dbpt := valt[0] + dbpt.DB.Close() + delete(b.availablePool, d.con) + } + } + b.mu.Unlock() + } + trc.Trace1("pooling.go: Timeout() - EXIT") +} + +//Release will close all the connections in the pool +func (p *Pool) Release() { + trc.Trace1("pooling.go: Release() - ENTRY") + + if p.availablePool != nil { + for _, vala := range p.availablePool { + for _, dbpr := range vala { + dbpr.DB.Close() + } + } + p.availablePool = nil + } + if p.usedPool != nil { + for _, valu := range p.usedPool { + for _, dbpr := range valu { + dbpr.DB.Close() + } + } + p.usedPool = nil + } + trc.Trace1("pooling.go: Release() - EXIT") +} + +//Set the connMaxLifetime +func (p *Pool) SetConnMaxLifetime(num int) { + trc.Trace1("pooling.go: SetConnMaxLifetime()") + trc.Trace1(fmt.Sprintf("connMaxLifetime=%d", num)) + + connMaxLifetime = num +} + +// Display will print the values in the map +func (p *Pool) Display() { + fmt.Println(p.availablePool) + fmt.Println(p.usedPool) + fmt.Println(p.poolSize) +} diff --git a/vendor/github.com/ibmdb/go_ibm_db/result.go b/vendor/github.com/ibmdb/go_ibm_db/result.go new file mode 100644 index 00000000..35bbd991 --- /dev/null +++ b/vendor/github.com/ibmdb/go_ibm_db/result.go @@ -0,0 +1,22 @@ +// Copyright 2012 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package go_ibm_db + +import ( + "errors" +) + +type Result struct { + rowCount int64 +} + +func (r *Result) LastInsertId() (int64, error) { + // TODO(brainman): implement (*Resilt).LastInsertId + return 0, errors.New("not implemented") +} + +func (r *Result) RowsAffected() (int64, error) { + return r.rowCount, nil +} diff --git a/vendor/github.com/ibmdb/go_ibm_db/rows.go b/vendor/github.com/ibmdb/go_ibm_db/rows.go new file mode 100644 index 00000000..af4cdd7b --- /dev/null +++ b/vendor/github.com/ibmdb/go_ibm_db/rows.go @@ -0,0 +1,181 @@ +// Copyright 2012 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package go_ibm_db + +import ( + "database/sql/driver" + "fmt" + "io" + "reflect" + "unsafe" + + "github.com/ibmdb/go_ibm_db/api" + trc "github.com/ibmdb/go_ibm_db/log2" +) + +type Rows struct { + os *ODBCStmt +} + +func (r *Rows) Columns() []string { + trc.Trace1("rows.go: Columns()") + + names := make([]string, len(r.os.Cols)) + for i := 0; i < len(names); i++ { + names[i] = r.os.Cols[i].Name() + } + return names +} + +func (r *Rows) ColumnTypePrecisionScale(index int) (precision, scale int64, ok bool) { + //TODO(Akhil):This functions retuns the precision and scale of column. + trc.Trace1("rows.go: ColumnTypePrecisionScale() - ENTRY") + trc.Trace1(fmt.Sprintf("index=%d", index)) + + ok = false; + var namelen api.SQLSMALLINT + namebuf := make([]byte, api.MAX_FIELD_SIZE) + ret := api.SQLColAttribute(r.os.h, api.SQLUSMALLINT(index+1), api.SQL_DESC_TYPE_NAME, api.SQLPOINTER(unsafe.Pointer(&namebuf[0])), (api.MAX_FIELD_SIZE), (*api.SQLSMALLINT)(&namelen), (api.SQLPOINTER)(unsafe.Pointer(nil))) + + if IsError(ret) { + fmt.Println(ret) + trc.Trace1(fmt.Sprintf("Error: %s",ret)) + return 0, 0, false + } + dbtype := string(namebuf[:namelen]) + ret = api.SQLColAttribute(r.os.h, api.SQLUSMALLINT(index+1), api.SQL_DESC_PRECISION, api.SQLPOINTER(unsafe.Pointer(nil)), 0, (*api.SQLSMALLINT)(nil), (api.SQLPOINTER)(unsafe.Pointer(&precision))) + if IsError(ret) { + fmt.Println(ret) + trc.Trace1(fmt.Sprintf("Error: %s",ret)) + return 0, 0, false + } + ret = api.SQLColAttribute(r.os.h, api.SQLUSMALLINT(index+1), api.SQL_DESC_SCALE, api.SQLPOINTER(unsafe.Pointer(nil)), 0, (*api.SQLSMALLINT)(nil), (api.SQLPOINTER)(unsafe.Pointer(&scale))) + if IsError(ret) { + fmt.Println(ret) + trc.Trace1(fmt.Sprintf("Error: %s",ret)) + return 0, 0, false + } + if dbtype == "DECIMAL" { + ok = true; + } else if dbtype == "NUMERIC" { + ok = true; + } else if dbtype == "TIMESTAMP" { + ok = true; + } + + trc.Trace1(fmt.Sprintf("precision=%d, scale=%d", precision, scale)) + trc.Trace1("rows.go: ColumnTypePrecisionScale() - EXIT") + return precision, scale, ok +} + +func (r *Rows) ColumnTypeLength(index int) (length int64, ok bool) { + //ToDo(Akhil):This functions retuns the length of column. + trc.Trace1("rows.go: ColumnTypeLength() - ENTRY") + + ret := api.SQLColAttribute(r.os.h, api.SQLUSMALLINT(index+1), api.SQL_DESC_LENGTH, api.SQLPOINTER(unsafe.Pointer(nil)), 0, (*api.SQLSMALLINT)(nil), (api.SQLPOINTER)(unsafe.Pointer(&length))) + if IsError(ret) { + fmt.Println(ret) + return 0, false + } + trc.Trace1("rows.go: ColumnTypeLength() - EXIT") + return length, true +} + +func (r *Rows) ColumnTypeNullable(index int) (nullable, ok bool) { + //TODO(Akhil):This functions retuns whether the column is nullable or not + trc.Trace1("rows.go: ColumnTypeNullable() - ENTRY") + + var null int64 + ret := api.SQLColAttribute(r.os.h, api.SQLUSMALLINT(index+1), api.SQL_DESC_NULLABLE, api.SQLPOINTER(unsafe.Pointer(nil)), 0, (*api.SQLSMALLINT)(nil), (api.SQLPOINTER)(unsafe.Pointer(&null))) + if IsError(ret) { + fmt.Println(ret) + return false, false + } + if null == api.SQL_NULLABLE { + return true, true + } + trc.Trace1("rows.go: ColumnTypeNullable() - EXIT") + return false, true +} + +func (r *Rows) ColumnTypeScanType(index int) reflect.Type { + //TODO(AKHIL):This function will return the scantype that can be used to scan + //the data to the golang variable. + trc.Trace1("rows.go: ColumnTypeScanType()") + trc.Trace1(fmt.Sprintf("index=%d", index)) + + a := r.os.Cols[index].TypeScan() + return (a) +} + +func (r *Rows) ColumnTypeDatabaseTypeName(index int) string { + //TODO(AKHIL):This functions retuns the dbtype(VARCHAR,DECIMAL etc..) of column. + //namebuf can be of uint8 or byte + trc.Trace1("rows.go: ColumnTypeDatabaseTypeName() - ENTRY") + + var namelen api.SQLSMALLINT + namebuf := make([]byte, api.MAX_FIELD_SIZE) + ret := api.SQLColAttribute(r.os.h, api.SQLUSMALLINT(index+1), api.SQL_DESC_TYPE_NAME, api.SQLPOINTER(unsafe.Pointer(&namebuf[0])), (api.MAX_FIELD_SIZE), (*api.SQLSMALLINT)(&namelen), (api.SQLPOINTER)(unsafe.Pointer(nil))) + + if IsError(ret) { + fmt.Println(ret) + return "" + } + dbtype := string(namebuf[:namelen]) + trc.Trace1("rows.go: ColumnTypeDatabaseTypeName() - EXIT") + return dbtype +} + +func (r *Rows) Next(dest []driver.Value) error { + trc.Trace1("rows.go: Next() - ENTRY") + + ret := api.SQLFetch(r.os.h) + if ret == api.SQL_NO_DATA { + return io.EOF + } + if IsError(ret) { + return NewError("SQLFetch", r.os.h) + } + for i := range dest { + v, err := r.os.Cols[i].Value(r.os.h, i) + if err != nil { + return err + } + dest[i] = v + } + trc.Trace1("rows.go: Next() - EXIT") + return nil +} + +func (r *Rows) HasNextResultSet() bool { + trc.Trace1("rows.go: HasVextResultSet()") + + return true +} + +func (r *Rows) NextResultSet() error { + trc.Trace1("rows.go: NextResultSet() - ENTRY") + + ret := api.SQLMoreResults(r.os.h) + if ret == api.SQL_NO_DATA { + return io.EOF + } + if IsError(ret) { + return NewError("SQLMoreResults", r.os.h) + } + + err := r.os.BindColumns() + if err != nil { + return err + } + trc.Trace1("rows.go: NextResultSet() - EXIT") + return nil +} + +func (r *Rows) Close() error { + trc.Trace1("rows.go: Close()") + + return r.os.closeByRows() +} diff --git a/vendor/github.com/ibmdb/go_ibm_db/sqlOut.go b/vendor/github.com/ibmdb/go_ibm_db/sqlOut.go new file mode 100644 index 00000000..9fbed484 --- /dev/null +++ b/vendor/github.com/ibmdb/go_ibm_db/sqlOut.go @@ -0,0 +1,524 @@ +package go_ibm_db + +import ( + "bytes" + "database/sql" + "database/sql/driver" + "errors" + "fmt" + "reflect" + "strconv" + "time" + "unsafe" + + "github.com/ibmdb/go_ibm_db/api" + trc "github.com/ibmdb/go_ibm_db/log2" +) + +// Out struct is used to store the value of a OUT parameter in Stored Procedure +type Out struct { + sqlOut *sql.Out + idx int + data []byte + ctype api.SQLSMALLINT + sqltype api.SQLSMALLINT + decimalDigits api.SQLSMALLINT + nullable api.SQLSMALLINT + inputOutputType api.SQLSMALLINT + parameterSize api.SQLULEN + buflen api.SQLLEN + plen *api.SQLLEN +} + +func newOut(hstmt api.SQLHSTMT, sqlOut *sql.Out, idx int) (*Out, error) { + trc.Trace1("sqlOut.go: newOut() - ENTRY") + trc.Trace1(fmt.Sprintf("idx=%d", idx)) + + var ctype, sqltype, decimalDigits, nullable, inputOutputType api.SQLSMALLINT + var parameterSize api.SQLULEN + var buflen api.SQLLEN + var plen *api.SQLLEN + var data []byte + if sqlOut.In { + inputOutputType = api.SQL_PARAM_INPUT_OUTPUT + //convert sql.Out.Dest to a driver.Value so the number of possible type is limited. + dv, err := driver.DefaultParameterConverter.ConvertValue(sqlOut.Dest) + if err != nil { + return nil, fmt.Errorf("%v : failed to convert Dest in sql.Out to driver.Value", err) + } + // use case with one type only. Otherwise d will turn into some other type and extract + // will give incorrect result + switch d := dv.(type) { + case nil: + var ind api.SQLLEN = api.SQL_NULL_DATA + // nil has no type, so use SQLDescribeParam + ret := api.SQLDescribeParam(hstmt, api.SQLUSMALLINT(idx+1), + &sqltype, ¶meterSize, &decimalDigits, &nullable) + if IsError(ret) { + return nil, NewError("SQLDescribeParam", hstmt) + } + // input value might be nil but the output value may not be so allocate buffer for output + data = make([]byte, parameterSize) + ctype = SqltoCtype(sqltype) + buflen = api.SQLLEN(len(data)) + plen = &ind + case string: + var ind api.SQLLEN = api.SQL_NTS + // string output buffer cannot be same as input, so use SQLDescribeParam + ret := api.SQLDescribeParam(hstmt, api.SQLUSMALLINT(idx+1), + &sqltype, ¶meterSize, &decimalDigits, &nullable) + if IsError(ret) { + return nil, NewError("SQLDescribeParam", hstmt) + } + ctype = api.SQL_C_WCHAR + sqltype = api.SQL_WCHAR + s16 := api.StringToUTF16(d) + b := api.ExtractUTF16Str(s16) + data = make([]byte, (parameterSize*2)+2) + if len(b) > len(data) { + return nil, + fmt.Errorf("At param. index %d INOUT string size is greater than the allocated OUT buffer size", idx+1) + } + copy(data, b) + buflen = api.SQLLEN(len(data)) + // use SQL_NTS to indicate that the string null terminated + plen = &ind + case int64: + ctype = api.SQL_C_SBIGINT + sqltype = api.SQL_BIGINT + data = api.Extract(unsafe.Pointer(&d), unsafe.Sizeof(d)) + parameterSize = 8 + case float64: + ctype = api.SQL_C_DOUBLE + sqltype = api.SQL_DOUBLE + data = api.Extract(unsafe.Pointer(&d), unsafe.Sizeof(d)) + parameterSize = 8 + case bool: + var b byte + if d { + b = 1 + } + ctype = api.SQL_C_BIT + sqltype = api.SQL_BIT + data = api.Extract(unsafe.Pointer(&b), unsafe.Sizeof(b)) + parameterSize = 1 + case time.Time: + ctype = api.SQL_C_TYPE_TIMESTAMP + sqltype = api.SQL_TYPE_TIMESTAMP + y, m, day := d.Date() + t := api.SQL_TIMESTAMP_STRUCT{ + Year: api.SQLSMALLINT(y), + Month: api.SQLUSMALLINT(m), + Day: api.SQLUSMALLINT(day), + Hour: api.SQLUSMALLINT(d.Hour()), + Minute: api.SQLUSMALLINT(d.Minute()), + Second: api.SQLUSMALLINT(d.Second()), + Fraction: api.SQLUINTEGER(d.Nanosecond()), + } + data = api.Extract(unsafe.Pointer(&t), unsafe.Sizeof(t)) + decimalDigits = 3 + parameterSize = 20 + api.SQLULEN(decimalDigits) + case []byte: + ctype = api.SQL_C_BINARY + sqltype = api.SQL_BINARY + data = make([]byte, len(d)) + copy(data, d) + buflen = api.SQLLEN(len(data)) + plen = &buflen + parameterSize = api.SQLULEN(len(data)) + default: + panic(fmt.Errorf("unsupported sql.Out.Dest type %T", d)) + } + } else { + inputOutputType = api.SQL_PARAM_OUTPUT + ret := api.SQLDescribeParam(hstmt, api.SQLUSMALLINT(idx+1), + &sqltype, ¶meterSize, &decimalDigits, &nullable) + if IsError(ret) { + return nil, NewError("SQLDescribeParam", hstmt) + } + data = make([]byte, parameterSize + 1) + ctype = SqltoCtype(sqltype) + buflen = api.SQLLEN(len(data)) + plen = &buflen + } + + trc.Trace1("sqlOut.go: newOut() - EXIT") + return &Out{ + sqlOut: sqlOut, + idx: idx + 1, + ctype: ctype, + sqltype: sqltype, + decimalDigits: decimalDigits, + nullable: nullable, + inputOutputType: inputOutputType, + parameterSize: parameterSize, + data: data, + buflen: buflen, + plen: plen, + }, nil +} + +// Value function converts the database value to driver.value +func (o *Out) Value() (driver.Value, error) { + trc.Trace1("sqlOut.go: Value() - ENTRY") + + var p unsafe.Pointer + buf := o.data + if len(buf) > 0 { + p = unsafe.Pointer(&buf[0]) + } + switch o.ctype { + case api.SQL_C_BIT: + return buf[0] != 0, nil + case api.SQL_C_LONG: + return *((*int32)(p)), nil + case api.SQL_C_SBIGINT: + return *((*int64)(p)), nil + case api.SQL_C_DOUBLE: + return *((*float64)(p)), nil + case api.SQL_C_CHAR: + buf = bytes.Trim(buf, "\x00") + return buf, nil + case api.SQL_C_WCHAR: + if p == nil { + return nil, nil + } + s := (*[1 << 20]uint16)(p)[:len(buf)/2] + return utf16toutf8(s), nil + case api.SQL_C_DBCHAR: + if p == nil { + return nil, nil + } + s := (*[1 << 20]uint8)(p)[:len(buf)] + return removeNulls(s), nil + case api.SQL_C_TYPE_TIMESTAMP: + t := (*api.SQL_TIMESTAMP_STRUCT)(p) + r := time.Date(int(t.Year), time.Month(t.Month), int(t.Day), + int(t.Hour), int(t.Minute), int(t.Second), int(t.Fraction), + time.Local) + return r, nil + case api.SQL_C_TYPE_DATE: + t := (*api.SQL_DATE_STRUCT)(p) + r := time.Date(int(t.Year), time.Month(t.Month), int(t.Day), + 0, 0, 0, 0, time.Local) + return r, nil + case api.SQL_C_TYPE_TIME: + t := (*api.SQL_TIME_STRUCT)(p) + r := time.Date(0, 0, 0, + int(t.Hour), + int(t.Minute), + int(t.Second), + 0, + time.Local) + return r, nil + case api.SQL_C_BINARY: + return buf, nil + } + trc.Trace1("sqlOut.go: Value() - EXIT") + return nil, fmt.Errorf("unsupported ctype %d for OUT parameter", o.ctype) +} + +// ConvertAssign function copies the database data to Dest field in stored procedure. +func (o *Out) ConvertAssign() error { + trc.Trace1("sqlOut.go: ConvertAssign() - ENTRY") + + if o.sqlOut == nil { + return fmt.Errorf("sql.Out is nil at OUT param index %d", o.idx) + } + + if o.sqlOut.Dest == nil { + return fmt.Errorf("Dest is nil at OUT param index %d", o.idx) + } + + destInfo := reflect.ValueOf(o.sqlOut.Dest) + if destInfo.Kind() != reflect.Ptr { + return fmt.Errorf("Dest at OUT param index %d is not a pointer", o.idx) + } + + dv, err := o.Value() + if err != nil { + return err + } + trc.Trace1("sqlOut.go: ConvertAssign() - EXIT") + return ConvertAssign(o.sqlOut.Dest, dv) +} + +// ConvertAssign function copies the database data to Dest field in stored procedure. +func ConvertAssign(dest, src interface{}) error { + trc.Trace1("sqlOut.go: ConvertAssign() - ENTRY") + + switch s := src.(type) { + case string: + switch d := dest.(type) { + case *string: + if d == nil { + return errors.New("destination pointer is nil") + } + *d = s + return nil + case *[]byte: + if d == nil { + return errors.New("destination pointer is nil") + } + *d = []byte(s) + return nil + case *sql.RawBytes: + if d == nil { + return errors.New("destination pointer is nil") + } + *d = append((*d)[:0], s...) + return nil + } + case []byte: + switch d := dest.(type) { + case *string: + if d == nil { + return errors.New("destination pointer is nil") + } + *d = string(s) + return nil + case *interface{}: + if d == nil { + return errors.New("destination pointer is nil") + } + *d = copyBytes(s) + return nil + case *[]byte: + if d == nil { + return errors.New("destination pointer is nil") + } + *d = copyBytes(s) + return nil + case *sql.RawBytes: + if d == nil { + return errors.New("destination pointer is nil") + } + *d = s + return nil + } + case time.Time: + switch d := dest.(type) { + case *time.Time: + *d = s + return nil + case *string: + *d = s.Format(time.RFC3339Nano) + return nil + case *[]byte: + if d == nil { + return errors.New("destination pointer is nil") + } + *d = []byte(s.Format(time.RFC3339Nano)) + return nil + case *sql.RawBytes: + if d == nil { + return errors.New("destination pointer is nil") + } + *d = s.AppendFormat((*d)[:0], time.RFC3339Nano) + return nil + } + case nil: + switch d := dest.(type) { + case *interface{}: + if d == nil { + return errors.New("destination pointer is nil") + } + *d = nil + return nil + case *[]byte: + if d == nil { + return errors.New("destination pointer is nil") + } + *d = nil + return nil + case *sql.RawBytes: + if d == nil { + return errors.New("destination pointer is nil") + } + *d = nil + return nil + } + } + + var sv reflect.Value + + switch d := dest.(type) { + case *string: + sv = reflect.ValueOf(src) + switch sv.Kind() { + case reflect.Bool, + reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, + reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, + reflect.Float32, reflect.Float64: + *d = asString(src) + return nil + } + case *[]byte: + sv = reflect.ValueOf(src) + if b, ok := asBytes(nil, sv); ok { + *d = b + return nil + } + case *sql.RawBytes: + sv = reflect.ValueOf(src) + if b, ok := asBytes([]byte(*d)[:0], sv); ok { + *d = sql.RawBytes(b) + return nil + } + case *interface{}: + *d = src + return nil + } + + if scanner, ok := dest.(sql.Scanner); ok { + return scanner.Scan(src) + } + + dpv := reflect.ValueOf(dest) + if dpv.Kind() != reflect.Ptr { + return errors.New("destination not a pointer") + } + if dpv.IsNil() { + return errors.New("destination pointer is nil") + } + + if !sv.IsValid() { + sv = reflect.ValueOf(src) + } + + dv := reflect.Indirect(dpv) + if sv.IsValid() && sv.Type().AssignableTo(dv.Type()) { + switch b := src.(type) { + case []byte: + dv.Set(reflect.ValueOf(copyBytes(b))) + default: + dv.Set(sv) + } + return nil + } + + if dv.Kind() == sv.Kind() && sv.Type().ConvertibleTo(dv.Type()) { + dv.Set(sv.Convert(dv.Type())) + return nil + } + switch dv.Kind() { + case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: + s := asString(src) + i64, err := strconv.ParseInt(s, 10, dv.Type().Bits()) + if err != nil { + err = strconvErr(err) + return fmt.Errorf("converting driver.Value type %T (%q) to a %s: %v", src, s, dv.Kind(), err) + } + dv.SetInt(i64) + return nil + case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64: + s := asString(src) + u64, err := strconv.ParseUint(s, 10, dv.Type().Bits()) + if err != nil { + err = strconvErr(err) + return fmt.Errorf("converting driver.Value type %T (%q) to a %s: %v", src, s, dv.Kind(), err) + } + dv.SetUint(u64) + return nil + case reflect.Float32, reflect.Float64: + s := asString(src) + f64, err := strconv.ParseFloat(s, dv.Type().Bits()) + if err != nil { + err = strconvErr(err) + return fmt.Errorf("converting driver.Value type %T (%q) to a %s: %v", src, s, dv.Kind(), err) + } + dv.SetFloat(f64) + return nil + case reflect.String: + switch v := src.(type) { + case string: + dv.SetString(v) + return nil + case []byte: + dv.SetString(string(v)) + return nil + } + } + + trc.Trace1("sqlOut.go: ConvertAssign() - EXIT") + return fmt.Errorf("unsupported Scan, storing driver.Value type %T into type %T", src, dest) +} + +func strconvErr(err error) error { + trc.Trace1("sqlOut.go: strconvErr()") + trc.Trace1(fmt.Sprintf("Error:%s", err)) + + if ne, ok := err.(*strconv.NumError); ok { + return ne.Err + } + return err +} + +func copyBytes(b []byte) []byte { + trc.Trace1("sqlOut.go: copyBytes()") + + if b == nil { + return nil + } + c := make([]byte, len(b)) + copy(c, b) + return c +} + +func asString(src interface{}) string { + trc.Trace1("sqlOut.go: asString()") + + switch v := src.(type) { + case string: + return v + case []byte: + return string(v) + } + rv := reflect.ValueOf(src) + switch rv.Kind() { + case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: + return strconv.FormatInt(rv.Int(), 10) + case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64: + return strconv.FormatUint(rv.Uint(), 10) + case reflect.Float64: + return strconv.FormatFloat(rv.Float(), 'g', -1, 64) + case reflect.Float32: + return strconv.FormatFloat(rv.Float(), 'g', -1, 32) + case reflect.Bool: + return strconv.FormatBool(rv.Bool()) + } + return fmt.Sprintf("%v", src) +} + +func asBytes(buf []byte, rv reflect.Value) (b []byte, ok bool) { + trc.Trace1("sqlOut.go: asBytes()") + + switch rv.Kind() { + case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: + return strconv.AppendInt(buf, rv.Int(), 10), true + case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64: + return strconv.AppendUint(buf, rv.Uint(), 10), true + case reflect.Float32: + return strconv.AppendFloat(buf, rv.Float(), 'g', -1, 32), true + case reflect.Float64: + return strconv.AppendFloat(buf, rv.Float(), 'g', -1, 64), true + case reflect.Bool: + return strconv.AppendBool(buf, rv.Bool()), true + case reflect.String: + s := rv.String() + return append(buf, s...), true + } + return +} + +// This function is mirrored in the database/sql/driver package. +func callValuerValue(vr driver.Valuer) (v driver.Value, err error) { + trc.Trace1("sqlOut.go: callValuerValue()") + + if rv := reflect.ValueOf(vr); rv.Kind() == reflect.Ptr && + rv.IsNil() && + rv.Type().Elem().Implements(reflect.TypeOf((*driver.Valuer)(nil)).Elem()) { + return nil, nil + } + return vr.Value() +} diff --git a/vendor/github.com/ibmdb/go_ibm_db/stats.go b/vendor/github.com/ibmdb/go_ibm_db/stats.go new file mode 100644 index 00000000..323642fe --- /dev/null +++ b/vendor/github.com/ibmdb/go_ibm_db/stats.go @@ -0,0 +1,41 @@ +// Copyright 2012 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package go_ibm_db + +import ( + "fmt" + "sync" + + "github.com/ibmdb/go_ibm_db/api" + trc "github.com/ibmdb/go_ibm_db/log2" +) + +type Stats struct { + EnvCount int + ConnCount int + StmtCount int + mu sync.Mutex +} + +func (s *Stats) updateHandleCount(handleType api.SQLSMALLINT, change int) { + trc.Trace1("stats.go: updateHandleCount() - ENTRY") + trc.Trace1(fmt.Sprintf("change=%d", change)) + + s.mu.Lock() + defer s.mu.Unlock() + switch handleType { + case api.SQL_HANDLE_ENV: + s.EnvCount += change + case api.SQL_HANDLE_DBC: + s.ConnCount += change + case api.SQL_HANDLE_STMT: + s.StmtCount += change + default: + trc.Trace1(fmt.Sprintf("unexpected handle type %d", handleType)) + panic(fmt.Errorf("unexpected handle type %d", handleType)) + } + + trc.Trace1("stats.go: updateHandleCount() - EXIT") +} diff --git a/vendor/github.com/ibmdb/go_ibm_db/stmt.go b/vendor/github.com/ibmdb/go_ibm_db/stmt.go new file mode 100644 index 00000000..568c33e7 --- /dev/null +++ b/vendor/github.com/ibmdb/go_ibm_db/stmt.go @@ -0,0 +1,250 @@ +// Copyright 2012 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package go_ibm_db + +import ( + "database/sql" + "database/sql/driver" + "errors" + "sync" + "time" + "context" + "github.com/ibmdb/go_ibm_db/api" + "fmt" + trc "github.com/ibmdb/go_ibm_db/log2" +) + +type Stmt struct { + c *Conn + query string + os *ODBCStmt + mu sync.Mutex +} + +func (c *Conn) Prepare( query string) (driver.Stmt, error) { + trc.Trace1("stmt.go: Prepare()") + trc.Trace1(fmt.Sprintf("query=%s", query)) + + return c.PrepareContext(context.Background(), query) +} + + +func (c *Conn) PrepareContext(ctx context.Context, query string) (driver.Stmt, error) { + trc.Trace1("stmt.go: PrepareContext() - ENTRY") + trc.Trace1(fmt.Sprintf("query=%s", query)) + + os, err := c.PrepareODBCStmt(query) + if err != nil { + return nil, err + } + + select { + default: + case <-ctx.Done(): + return nil, ctx.Err() + } + trc.Trace1("stmt.go: PrepareContext() - EXIT") + return &Stmt{c: c, os: os, query: query}, nil +} + +func (s *Stmt) NumInput() int { + trc.Trace1("stmt.go: NumInput()") + + if s.os == nil { + return -1 + } + return len(s.os.Parameters) +} + +// Close closes the opened statement +func (s *Stmt) Close() error { + trc.Trace1("stmt.go: Close() - ENTRY") + + if s.os == nil { + return errors.New("Stmt is already closed") + } + ret := s.os.closeByStmt() + s.os = nil + + trc.Trace1("stmt.go: Close() - EXIT") + return ret +} + +// Exec executes the the sql but does not return the rows +func (s *Stmt) Exec(args []driver.Value) (driver.Result, error) { + trc.Trace1("stmt.go: Exec()") + + return s.exec(context.Background(), args) +} + +// ExecContext implements driver.StmtExecContext interface +func (s *Stmt) ExecContext(ctx context.Context, args []driver.NamedValue) (driver.Result, error) { + trc.Trace1("stmt.go: ExecContext()") + + dargs := make([]driver.Value, len(args)) + for n, param := range args { + dargs[n] = param.Value + } + + return s.exec(ctx, dargs) +} +func (s *Stmt) exec(ctx context.Context, args []driver.Value) (driver.Result, error) { + trc.Trace1("stmt.go: exec()- ENTRY") + + if s.os == nil { + return nil, errors.New("Stmt is closed") + } + + s.mu.Lock() + defer s.mu.Unlock() + if s.os.usedByRows { + s.os.closeByStmt() + s.os = nil + os, err := s.c.PrepareODBCStmt(s.query) + if err != nil { + return nil, err + } + s.os = os + } + err := s.os.Exec(args) + if err != nil { + return nil, err + } + var sumRowCount int64 + for { + var c api.SQLLEN + ret := api.SQLRowCount(s.os.h, &c) + if IsError(ret) { + return nil, NewError("SQLRowCount", s.os.h) + } + sumRowCount += int64(c) + if ret = api.SQLMoreResults(s.os.h); ret == api.SQL_NO_DATA { + break + } + } + + select { + default: + case <-ctx.Done(): + return nil, ctx.Err() + } + + trc.Trace1("stmt.go: exec()- EXIT") + return &Result{rowCount: sumRowCount}, nil +} + +// Query function executes the sql and return rows if rows are present +func (s *Stmt) Query(args []driver.Value) (driver.Rows, error) { + trc.Trace1("stmt.go: Query()") + + return s.query1(context.Background(), args) +} + +// QueryContext implements driver.StmtQueryContext interface +func (s *Stmt) QueryContext(ctx context.Context, args []driver.NamedValue) (driver.Rows, error) { + trc.Trace1("stmt.go: QueryContext()") + + dargs := make([]driver.Value, len(args)) + for n, param := range args { + dargs[n] = param.Value + } + + return s.query1(ctx, dargs) +} + +func (s *Stmt) query1(ctx context.Context, args []driver.Value) (driver.Rows, error) { + trc.Trace1("stmt.go: query1()") + + if s.os == nil { + return nil, errors.New("Stmt is closed") + } + s.mu.Lock() + defer s.mu.Unlock() + if s.os.usedByRows { + s.os.closeByStmt() + s.os = nil + os, err := s.c.PrepareODBCStmt(s.query) + if err != nil { + return nil, err + } + s.os = os + } + err := s.os.Exec(args) + if err != nil { + return nil, err + } + err = s.os.BindColumns() + if err != nil { + return nil, err + } + s.os.usedByRows = true // now both Stmt and Rows refer to it + + select { + default: + case <-ctx.Done(): + return nil, ctx.Err() + } + + return &Rows{os: s.os}, nil +} + +// CheckNamedValue implementes driver.NamedValueChecker. +func (s *Stmt) CheckNamedValue(nv *driver.NamedValue) (err error) { + trc.Trace1("stmt.go: CheckNamedValue() - ENTRY") + + switch d := nv.Value.(type) { + case sql.Out: + err = nil + case []int: + temp := make([]int64, len(d)) + for i := 0; i < len(d); i++ { + temp[i] = int64(d[i]) + } + nv.Value = temp + err = nil + case []int8: + temp := make([]int64, len(d)) + for i := 0; i < len(d); i++ { + temp[i] = int64(d[i]) + } + nv.Value = temp + err = nil + case []int16: + temp := make([]int64, len(d)) + for i := 0; i < len(d); i++ { + temp[i] = int64(d[i]) + } + nv.Value = temp + err = nil + case []int32: + temp := make([]int64, len(d)) + for i := 0; i < len(d); i++ { + temp[i] = int64(d[i]) + } + nv.Value = temp + err = nil + case []int64: + err = nil + case []string: + err = nil + case []bool: + err = nil + case []float64: + err = nil + case []float32: + temp := make([]float64, len(d)) + for i := 0; i < len(d); i++ { + temp[i] = float64(d[i]) + } + nv.Value = temp + err = nil + case []time.Time: + err = nil + default: + nv.Value, err = driver.DefaultParameterConverter.ConvertValue(nv.Value) + } + trc.Trace1("stmt.go: CheckNamedValue() - EXIT") + return err +} diff --git a/vendor/github.com/ibmdb/go_ibm_db/tx.go b/vendor/github.com/ibmdb/go_ibm_db/tx.go new file mode 100644 index 00000000..1966d12b --- /dev/null +++ b/vendor/github.com/ibmdb/go_ibm_db/tx.go @@ -0,0 +1,67 @@ +// Copyright 2012 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package go_ibm_db + +import ( + "database/sql/driver" + "errors" + + "github.com/ibmdb/go_ibm_db/api" +) + +type Tx struct { + c *Conn +} + +func (c *Conn) setAutoCommitAttr(a uintptr) error { + ret := api.SQLSetConnectUIntPtrAttr(c.h, api.SQL_ATTR_AUTOCOMMIT, + a, api.SQL_IS_UINTEGER) + if IsError(ret) { + return NewError("SQLSetConnectUIntPtrAttr", c.h) + } + return nil +} + +func (c *Conn) Begin() (driver.Tx, error) { + if c.tx != nil { + return nil, errors.New("already in a transaction") + } + err := c.setAutoCommitAttr(api.SQL_AUTOCOMMIT_OFF) + if err != nil { + return nil, err + } + c.tx = &Tx{c: c} + return c.tx, nil +} + +func (c *Conn) endTx(commit bool) error { + if c.tx == nil { + return errors.New("not in a transaction") + } + c.tx = nil + var howToEnd api.SQLSMALLINT + if commit { + howToEnd = api.SQL_COMMIT + } else { + howToEnd = api.SQL_ROLLBACK + } + ret := api.SQLEndTran(api.SQL_HANDLE_DBC, api.SQLHANDLE(c.h), howToEnd) + if IsError(ret) { + return NewError("SQLEndTran", c.h) + } + err := c.setAutoCommitAttr(api.SQL_AUTOCOMMIT_ON) + if err != nil { + return err + } + return nil +} + +func (tx *Tx) Commit() error { + return tx.c.endTx(true) +} + +func (tx *Tx) Rollback() error { + return tx.c.endTx(false) +} diff --git a/vendor/github.com/ibmdb/go_ibm_db/utf16.go b/vendor/github.com/ibmdb/go_ibm_db/utf16.go new file mode 100644 index 00000000..54444f35 --- /dev/null +++ b/vendor/github.com/ibmdb/go_ibm_db/utf16.go @@ -0,0 +1,69 @@ +// Copyright 2013 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package go_ibm_db + +import ( + "unicode/utf16" + "unicode/utf8" +) + +const ( + replacementChar = '\uFFFD' // Unicode replacement character + + // 0xd800-0xdc00 encodes the high 10 bits of a pair. + // 0xdc00-0xe000 encodes the low 10 bits of a pair. + // the value is those 20 bits plus 0x10000. + surr1 = 0xd800 + surr2 = 0xdc00 + surr3 = 0xe000 +) + +// utf16toutf8 returns the UTF-8 encoding of the UTF-16 sequence s, +// with a terminating NUL removed. +func utf16toutf8(s []uint16) []byte { + for i, v := range s { + if v == 0 { + s = s[0:i] + break + } + } + buf := make([]byte, 0, len(s)*2) // allow 2 bytes for every rune + b := make([]byte, 4) + for i := 0; i < len(s); i++ { + var rr rune + switch r := s[i]; { + case surr1 <= r && r < surr2 && i+1 < len(s) && + surr2 <= s[i+1] && s[i+1] < surr3: + // valid surrogate sequence + rr = utf16.DecodeRune(rune(r), rune(s[i+1])) + i++ + case surr1 <= r && r < surr3: + // invalid surrogate sequence + rr = replacementChar + default: + // normal rune + rr = rune(r) + } + b := b[:cap(b)] + n := utf8.EncodeRune(b, rr) + b = b[:n] + buf = append(buf, b...) + } + return buf +} + +//This func takes []uint8 array and then removes the null +//and then returns []uint8 +func removeNulls(s []uint8) []uint8 { + buf := make([]uint8, len(s)) + ind := 0 + for _, v := range s { + if v != 0 { + buf[ind] = v + ind++ + } + } + return buf +} diff --git a/vendor/github.com/ibmruntimes/go-recordio/v2/LICENSE b/vendor/github.com/ibmruntimes/go-recordio/v2/LICENSE new file mode 100644 index 00000000..bd37bdc2 --- /dev/null +++ b/vendor/github.com/ibmruntimes/go-recordio/v2/LICENSE @@ -0,0 +1,29 @@ +BSD 3-Clause License + +Copyright (c) 2021, IBM Runtime Technologies +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + +1. Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + +2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + +3. Neither the name of the copyright holder nor the names of its + contributors may be used to endorse or promote products derived from + this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/vendor/github.com/ibmruntimes/go-recordio/v2/PATENTS b/vendor/github.com/ibmruntimes/go-recordio/v2/PATENTS new file mode 100644 index 00000000..6e18bb98 --- /dev/null +++ b/vendor/github.com/ibmruntimes/go-recordio/v2/PATENTS @@ -0,0 +1,23 @@ +Additional IP Rights Grant (Patents) + +"This implementation" means the copyrightable works distributed by +International Business Machines Corporation (IBM) as part of the +zosrecordio in Go project. + +IBM hereby grants to You a perpetual, worldwide, non-exclusive, +no-charge, royalty-free, irrevocable (except as stated in this section) +patent license to make, have made, use, offer to sell, sell, import, +transfer and otherwise run, modify and propagate the contents of this +implementation of zosrecordio in Go, where such license applies only to those patent +claims, both currently owned or controlled by IBM and acquired in +the future, licensable by IBM that are necessarily infringed by this +implementation of zosrecordio in Go. This grant does not include claims that would be +infringed only as a consequence of further modification of this +implementation. If you or your agent or exclusive licensee institute or +order or agree to the institution of patent litigation against any +entity (including a cross-claim or counterclaim in a lawsuit) alleging +that this implementation of zosrecordio in Go or any code incorporated within this +implementation of zosrecordio in Go constitutes direct or contributory patent +infringement, or inducement of patent infringement, then any patent +rights granted to you under this License for this implementation of Go +shall terminate as of the date such litigation is filed. diff --git a/vendor/github.com/ibmruntimes/go-recordio/v2/utils/README.md b/vendor/github.com/ibmruntimes/go-recordio/v2/utils/README.md new file mode 100644 index 00000000..9a1375ab --- /dev/null +++ b/vendor/github.com/ibmruntimes/go-recordio/v2/utils/README.md @@ -0,0 +1,68 @@ +# LibVec offset generation + +* go run mklibvec.go + creates libvec_zos.go for your zos system + +# Utiliy functions + +# Usage + +* func Malloc31(size int) (ret unsafe.Pointer) + Allocate memory below the bar (<2G) + +* func Malloc24(size int) (ret unsafe.Pointer) + Allocate memory below the line (<16M) + +* func Free(ptr unsafe.Pointer) + Free allocated memory + +* func EtoA(record []byte) + Convert byte array from EBCDIC to ASCII + +* func AtoE(record []byte) + Convert byte array from ASCII to EBCDIC + +* func Bpxcall(plist []unsafe.Pointer, bpx_offset int64) + Perform a call to the USS assembly services. + +* func Svc8(r0 unsafe.Pointer, r1 uintptr) (rr0 unsafe.Pointer, rr1 uintptr, rr15 uintptr) + Perform the MVS macro SVC 8 (load module) + +* func Svc9(EntryPointName unsafe.Pointer) (r15 uintptr) + Perform the MVS macro SVC 9 (free module) + +* func Call24(p *ModuleInfo) uintptr + Branch to a loaded amode24 program + +* func Call31(p *ModuleInfo) uintptr + Branch to a loaded amode31 program + +* func Call64(p *ModuleInfo) uintptr + Branch to a loaded amode64 program + +* func Iefssreq(parm unsafe.Pointer, dsa unsafe.Pointer) (ret uintptr) + Perform the MVS macro IEFSSREQ + +* func LoadMod(name string) (ret *ModuleInfo) + Load the named module into memory + +* func ConvertStringToSlice(s string, bi []byte) (bo []byte) + Convert Go string to byte array + +* func ConvertTypeToSlice[T any](i T) (slice []byte) + Convert a generic type to byte array + +* func ConvertSliceToType[T1 any](bi []byte) (*T1, int) + Convert a byte slice to a generic type + +* func ConvertSliceToTypes[T1, T2 any](bi []byte) (*T1, *T2) + Convert a byte slice to a generic types + +* func ConvertSliceToTypes3[T1, T2, T3 any](bi []byte) (*T1, *T2, *T3) + Convert a byte slice to a generic types + +* func Perror() + Wrapper for the perror() function + +* func Dup2(oldfd uintptr, newfd uintptr) uintptr + Wrapper for the dup2() function diff --git a/vendor/github.com/ibmruntimes/go-recordio/v2/utils/libvec_zos.go b/vendor/github.com/ibmruntimes/go-recordio/v2/utils/libvec_zos.go new file mode 100644 index 00000000..b03b2052 --- /dev/null +++ b/vendor/github.com/ibmruntimes/go-recordio/v2/utils/libvec_zos.go @@ -0,0 +1,2849 @@ +//go:build zos +// +build zos + +package utils + +const ( + SYS_LOG = 0x17 // 23 + SYS_COSH = 0x18 // 24 + SYS_TANH = 0x19 // 25 + SYS_EXP = 0x1A // 26 + SYS_MODF = 0x1B // 27 + SYS_LOG10 = 0x1C // 28 + SYS_FREXP = 0x1D // 29 + SYS_LDEXP = 0x1E // 30 + SYS_CEIL = 0x1F // 31 + SYS_POW = 0x20 // 32 + SYS_SQRT = 0x21 // 33 + SYS_FLOOR = 0x22 // 34 + SYS_J1 = 0x23 // 35 + SYS_FABS = 0x24 // 36 + SYS_FMOD = 0x25 // 37 + SYS_J0 = 0x26 // 38 + SYS_YN = 0x27 // 39 + SYS_JN = 0x28 // 40 + SYS_Y0 = 0x29 // 41 + SYS_Y1 = 0x2A // 42 + SYS_HYPOT = 0x2B // 43 + SYS_ERF = 0x2C // 44 + SYS_ERFC = 0x2D // 45 + SYS_GAMMA = 0x2E // 46 + SYS_ISALPHA = 0x30 // 48 + SYS_ISALNUM = 0x31 // 49 + SYS_ISLOWER = 0x32 // 50 + SYS_ISCNTRL = 0x33 // 51 + SYS_ISDIGIT = 0x34 // 52 + SYS_ISGRAPH = 0x35 // 53 + SYS_ISUPPER = 0x36 // 54 + SYS_ISPRINT = 0x37 // 55 + SYS_ISPUNCT = 0x38 // 56 + SYS_ISSPACE = 0x39 // 57 + SYS_SETLOCAL = 0x3A // 58 + SYS_SETLOCALE = 0x3A // 58 + SYS_ISXDIGIT = 0x3B // 59 + SYS_TOLOWER = 0x3C // 60 + SYS_TOUPPER = 0x3D // 61 + SYS_ASIN = 0x3E // 62 + SYS_SIN = 0x3F // 63 + SYS_COS = 0x40 // 64 + SYS_TAN = 0x41 // 65 + SYS_SINH = 0x42 // 66 + SYS_ACOS = 0x43 // 67 + SYS_ATAN = 0x44 // 68 + SYS_ATAN2 = 0x45 // 69 + SYS_FTELL = 0x46 // 70 + SYS_FGETPOS = 0x47 // 71 + SYS_FSEEK = 0x48 // 72 + SYS_FSETPOS = 0x49 // 73 + SYS_FERROR = 0x4A // 74 + SYS_REWIND = 0x4B // 75 + SYS_CLEARERR = 0x4C // 76 + SYS_FEOF = 0x4D // 77 + SYS_ATOL = 0x4E // 78 + SYS_PERROR = 0x4F // 79 + SYS_ATOF = 0x50 // 80 + SYS_ATOI = 0x51 // 81 + SYS_RAND = 0x52 // 82 + SYS_STRTOD = 0x53 // 83 + SYS_STRTOL = 0x54 // 84 + SYS_STRTOUL = 0x55 // 85 + SYS_MALLOC = 0x56 // 86 + SYS_SRAND = 0x57 // 87 + SYS_CALLOC = 0x58 // 88 + SYS_FREE = 0x59 // 89 + SYS_EXIT = 0x5A // 90 + SYS_REALLOC = 0x5B // 91 + SYS_ABORT = 0x5C // 92 + SYS___ABORT = 0x5C // 92 + SYS_ATEXIT = 0x5D // 93 + SYS_RAISE = 0x5E // 94 + SYS_SETJMP = 0x5F // 95 + SYS_LONGJMP = 0x60 // 96 + SYS_SIGNAL = 0x61 // 97 + SYS_TMPNAM = 0x62 // 98 + SYS_REMOVE = 0x63 // 99 + SYS_RENAME = 0x64 // 100 + SYS_TMPFILE = 0x65 // 101 + SYS_FREOPEN = 0x66 // 102 + SYS_FCLOSE = 0x67 // 103 + SYS_FFLUSH = 0x68 // 104 + SYS_FOPEN = 0x69 // 105 + SYS_FSCANF = 0x6A // 106 + SYS_SETBUF = 0x6B // 107 + SYS_SETVBUF = 0x6C // 108 + SYS_FPRINTF = 0x6D // 109 + SYS_SSCANF = 0x6E // 110 + SYS_PRINTF = 0x6F // 111 + SYS_SCANF = 0x70 // 112 + SYS_SPRINTF = 0x71 // 113 + SYS_FGETC = 0x72 // 114 + SYS_VFPRINTF = 0x73 // 115 + SYS_VPRINTF = 0x74 // 116 + SYS_VSPRINTF = 0x75 // 117 + SYS_GETC = 0x76 // 118 + SYS_FGETS = 0x77 // 119 + SYS_FPUTC = 0x78 // 120 + SYS_FPUTS = 0x79 // 121 + SYS_PUTCHAR = 0x7A // 122 + SYS_GETCHAR = 0x7B // 123 + SYS_GETS = 0x7C // 124 + SYS_PUTC = 0x7D // 125 + SYS_FWRITE = 0x7E // 126 + SYS_PUTS = 0x7F // 127 + SYS_UNGETC = 0x80 // 128 + SYS_FREAD = 0x81 // 129 + SYS_WCSTOMBS = 0x82 // 130 + SYS_MBTOWC = 0x83 // 131 + SYS_WCTOMB = 0x84 // 132 + SYS_MBSTOWCS = 0x85 // 133 + SYS_WCSCPY = 0x86 // 134 + SYS_WCSCAT = 0x87 // 135 + SYS_WCSCHR = 0x88 // 136 + SYS_WCSCMP = 0x89 // 137 + SYS_WCSNCMP = 0x8A // 138 + SYS_WCSCSPN = 0x8B // 139 + SYS_WCSLEN = 0x8C // 140 + SYS_WCSNCAT = 0x8D // 141 + SYS_WCSSPN = 0x8E // 142 + SYS_WCSNCPY = 0x8F // 143 + SYS_ABS = 0x90 // 144 + SYS_DIV = 0x91 // 145 + SYS_LABS = 0x92 // 146 + SYS_STRNCPY = 0x93 // 147 + SYS_MEMCPY = 0x94 // 148 + SYS_MEMMOVE = 0x95 // 149 + SYS_STRCPY = 0x96 // 150 + SYS_STRCMP = 0x97 // 151 + SYS_STRCAT = 0x98 // 152 + SYS_STRNCAT = 0x99 // 153 + SYS_MEMCMP = 0x9A // 154 + SYS_MEMCHR = 0x9B // 155 + SYS_STRCOLL = 0x9C // 156 + SYS_STRNCMP = 0x9D // 157 + SYS_STRXFRM = 0x9E // 158 + SYS_STRRCHR = 0x9F // 159 + SYS_STRCHR = 0xA0 // 160 + SYS_STRCSPN = 0xA1 // 161 + SYS_STRPBRK = 0xA2 // 162 + SYS_MEMSET = 0xA3 // 163 + SYS_STRSPN = 0xA4 // 164 + SYS_STRSTR = 0xA5 // 165 + SYS_STRTOK = 0xA6 // 166 + SYS_DIFFTIME = 0xA7 // 167 + SYS_STRERROR = 0xA8 // 168 + SYS_STRLEN = 0xA9 // 169 + SYS_CLOCK = 0xAA // 170 + SYS_CTIME = 0xAB // 171 + SYS_MKTIME = 0xAC // 172 + SYS_TIME = 0xAD // 173 + SYS_ASCTIME = 0xAE // 174 + SYS_MBLEN = 0xAF // 175 + SYS_GMTIME = 0xB0 // 176 + SYS_LOCALTIM = 0xB1 // 177 + SYS_LOCALTIME = 0xB1 // 177 + SYS_STRFTIME = 0xB2 // 178 + SYS___GETCB = 0xB4 // 180 + SYS_FUPDATE = 0xB5 // 181 + SYS___FUPDT = 0xB5 // 181 + SYS_CLRMEMF = 0xBD // 189 + SYS___CLRMF = 0xBD // 189 + SYS_FETCHEP = 0xBF // 191 + SYS___FTCHEP = 0xBF // 191 + SYS_FLDATA = 0xC1 // 193 + SYS___FLDATA = 0xC1 // 193 + SYS_DYNFREE = 0xC2 // 194 + SYS___DYNFRE = 0xC2 // 194 + SYS_DYNALLOC = 0xC3 // 195 + SYS___DYNALL = 0xC3 // 195 + SYS___CDUMP = 0xC4 // 196 + SYS_CSNAP = 0xC5 // 197 + SYS___CSNAP = 0xC5 // 197 + SYS_CTRACE = 0xC6 // 198 + SYS___CTRACE = 0xC6 // 198 + SYS___CTEST = 0xC7 // 199 + SYS_SETENV = 0xC8 // 200 + SYS___SETENV = 0xC8 // 200 + SYS_CLEARENV = 0xC9 // 201 + SYS___CLRENV = 0xC9 // 201 + SYS___REGCOMP_STD = 0xEA // 234 + SYS_NL_LANGINFO = 0xFC // 252 + SYS_GETSYNTX = 0xFD // 253 + SYS_ISBLANK = 0xFE // 254 + SYS___ISBLNK = 0xFE // 254 + SYS_ISWALNUM = 0xFF // 255 + SYS_ISWALPHA = 0x100 // 256 + SYS_ISWBLANK = 0x101 // 257 + SYS___ISWBLK = 0x101 // 257 + SYS_ISWCNTRL = 0x102 // 258 + SYS_ISWDIGIT = 0x103 // 259 + SYS_ISWGRAPH = 0x104 // 260 + SYS_ISWLOWER = 0x105 // 261 + SYS_ISWPRINT = 0x106 // 262 + SYS_ISWPUNCT = 0x107 // 263 + SYS_ISWSPACE = 0x108 // 264 + SYS_ISWUPPER = 0x109 // 265 + SYS_ISWXDIGI = 0x10A // 266 + SYS_ISWXDIGIT = 0x10A // 266 + SYS_WCTYPE = 0x10B // 267 + SYS_ISWCTYPE = 0x10C // 268 + SYS_TOWLOWER = 0x10D // 269 + SYS_TOWUPPER = 0x10E // 270 + SYS_MBSINIT = 0x10F // 271 + SYS_WCTOB = 0x110 // 272 + SYS_MBRLEN = 0x111 // 273 + SYS_MBRTOWC = 0x112 // 274 + SYS_MBSRTOWC = 0x113 // 275 + SYS_MBSRTOWCS = 0x113 // 275 + SYS_WCRTOMB = 0x114 // 276 + SYS_WCSRTOMB = 0x115 // 277 + SYS_WCSRTOMBS = 0x115 // 277 + SYS___CSID = 0x116 // 278 + SYS___WCSID = 0x117 // 279 + SYS_STRPTIME = 0x118 // 280 + SYS___STRPTM = 0x118 // 280 + SYS_STRFMON = 0x119 // 281 + SYS___RPMTCH = 0x11A // 282 + SYS_WCSSTR = 0x11B // 283 + SYS_WCSTOK = 0x12C // 300 + SYS_WCSTOL = 0x12D // 301 + SYS_WCSTOD = 0x12E // 302 + SYS_WCSTOUL = 0x12F // 303 + SYS_WCSCOLL = 0x130 // 304 + SYS_WCSXFRM = 0x131 // 305 + SYS_WCSWIDTH = 0x132 // 306 + SYS_WCWIDTH = 0x133 // 307 + SYS_WCSFTIME = 0x134 // 308 + SYS_SWPRINTF = 0x135 // 309 + SYS_VSWPRINT = 0x136 // 310 + SYS_VSWPRINTF = 0x136 // 310 + SYS_SWSCANF = 0x137 // 311 + SYS_REGCOMP = 0x138 // 312 + SYS_REGEXEC = 0x139 // 313 + SYS_REGFREE = 0x13A // 314 + SYS_REGERROR = 0x13B // 315 + SYS_FGETWC = 0x13C // 316 + SYS_FGETWS = 0x13D // 317 + SYS_FPUTWC = 0x13E // 318 + SYS_FPUTWS = 0x13F // 319 + SYS_GETWC = 0x140 // 320 + SYS_GETWCHAR = 0x141 // 321 + SYS_PUTWC = 0x142 // 322 + SYS_PUTWCHAR = 0x143 // 323 + SYS_UNGETWC = 0x144 // 324 + SYS_ICONV_OPEN = 0x145 // 325 + SYS_ICONV = 0x146 // 326 + SYS_ICONV_CLOSE = 0x147 // 327 + SYS_ISMCCOLLEL = 0x14C // 332 + SYS_STRTOCOLL = 0x14D // 333 + SYS_COLLTOSTR = 0x14E // 334 + SYS_COLLEQUIV = 0x14F // 335 + SYS_COLLRANGE = 0x150 // 336 + SYS_CCLASS = 0x151 // 337 + SYS_COLLORDER = 0x152 // 338 + SYS___DEMANGLE = 0x154 // 340 + SYS_FDOPEN = 0x155 // 341 + SYS___ERRNO = 0x156 // 342 + SYS___ERRNO2 = 0x157 // 343 + SYS___TERROR = 0x158 // 344 + SYS_MAXCOLL = 0x169 // 361 + SYS_GETMCCOLL = 0x16A // 362 + SYS_GETWMCCOLL = 0x16B // 363 + SYS___ERR2AD = 0x16C // 364 + SYS_DLLQUERYFN = 0x16D // 365 + SYS_DLLQUERYVAR = 0x16E // 366 + SYS_DLLFREE = 0x16F // 367 + SYS_DLLLOAD = 0x170 // 368 + SYS__EXIT = 0x174 // 372 + SYS_ACCESS = 0x175 // 373 + SYS_ALARM = 0x176 // 374 + SYS_CFGETISPEED = 0x177 // 375 + SYS_CFGETOSPEED = 0x178 // 376 + SYS_CFSETISPEED = 0x179 // 377 + SYS_CFSETOSPEED = 0x17A // 378 + SYS_CHDIR = 0x17B // 379 + SYS_CHMOD = 0x17C // 380 + SYS_CHOWN = 0x17D // 381 + SYS_CLOSE = 0x17E // 382 + SYS_CLOSEDIR = 0x17F // 383 + SYS_CREAT = 0x180 // 384 + SYS_CTERMID = 0x181 // 385 + SYS_DUP = 0x182 // 386 + SYS_DUP2 = 0x183 // 387 + SYS_EXECL = 0x184 // 388 + SYS_EXECLE = 0x185 // 389 + SYS_EXECLP = 0x186 // 390 + SYS_EXECV = 0x187 // 391 + SYS_EXECVE = 0x188 // 392 + SYS_EXECVP = 0x189 // 393 + SYS_FCHMOD = 0x18A // 394 + SYS_FCHOWN = 0x18B // 395 + SYS_FCNTL = 0x18C // 396 + SYS_FILENO = 0x18D // 397 + SYS_FORK = 0x18E // 398 + SYS_FPATHCONF = 0x18F // 399 + SYS_FSTAT = 0x190 // 400 + SYS_FSYNC = 0x191 // 401 + SYS_FTRUNCATE = 0x192 // 402 + SYS_GETCWD = 0x193 // 403 + SYS_GETEGID = 0x194 // 404 + SYS_GETEUID = 0x195 // 405 + SYS_GETGID = 0x196 // 406 + SYS_GETGRGID = 0x197 // 407 + SYS_GETGRNAM = 0x198 // 408 + SYS_GETGROUPS = 0x199 // 409 + SYS_GETLOGIN = 0x19A // 410 + SYS_W_GETMNTENT = 0x19B // 411 + SYS_GETPGRP = 0x19C // 412 + SYS_GETPID = 0x19D // 413 + SYS_GETPPID = 0x19E // 414 + SYS_GETPWNAM = 0x19F // 415 + SYS_GETPWUID = 0x1A0 // 416 + SYS_GETUID = 0x1A1 // 417 + SYS_W_IOCTL = 0x1A2 // 418 + SYS_ISATTY = 0x1A3 // 419 + SYS_KILL = 0x1A4 // 420 + SYS_LINK = 0x1A5 // 421 + SYS_LSEEK = 0x1A6 // 422 + SYS_LSTAT = 0x1A7 // 423 + SYS_MKDIR = 0x1A8 // 424 + SYS_MKFIFO = 0x1A9 // 425 + SYS_MKNOD = 0x1AA // 426 + SYS_MOUNT = 0x1AB // 427 + SYS_OPEN = 0x1AC // 428 + SYS_OPENDIR = 0x1AD // 429 + SYS_PATHCONF = 0x1AE // 430 + SYS_PAUSE = 0x1AF // 431 + SYS_PIPE = 0x1B0 // 432 + SYS_W_GETPSENT = 0x1B1 // 433 + SYS_READ = 0x1B2 // 434 + SYS_READDIR = 0x1B3 // 435 + SYS_READLINK = 0x1B4 // 436 + SYS_REWINDDIR = 0x1B5 // 437 + SYS_RMDIR = 0x1B6 // 438 + SYS_SETEGID = 0x1B7 // 439 + SYS_SETEUID = 0x1B8 // 440 + SYS_SETGID = 0x1B9 // 441 + SYS_SETPGID = 0x1BA // 442 + SYS_SETSID = 0x1BB // 443 + SYS_SETUID = 0x1BC // 444 + SYS_SIGACTION = 0x1BD // 445 + SYS_SIGADDSET = 0x1BE // 446 + SYS_SIGDELSET = 0x1BF // 447 + SYS_SIGEMPTYSET = 0x1C0 // 448 + SYS_SIGFILLSET = 0x1C1 // 449 + SYS_SIGISMEMBER = 0x1C2 // 450 + SYS_SIGLONGJMP = 0x1C3 // 451 + SYS_SIGPENDING = 0x1C4 // 452 + SYS_SIGPROCMASK = 0x1C5 // 453 + SYS_SIGSETJMP = 0x1C6 // 454 + SYS_SIGSUSPEND = 0x1C7 // 455 + SYS_SLEEP = 0x1C8 // 456 + SYS_STAT = 0x1C9 // 457 + SYS_W_STATFS = 0x1CA // 458 + SYS_SYMLINK = 0x1CB // 459 + SYS_SYSCONF = 0x1CC // 460 + SYS_TCDRAIN = 0x1CD // 461 + SYS_TCFLOW = 0x1CE // 462 + SYS_TCFLUSH = 0x1CF // 463 + SYS_TCGETATTR = 0x1D0 // 464 + SYS_TCGETPGRP = 0x1D1 // 465 + SYS_TCSENDBREAK = 0x1D2 // 466 + SYS_TCSETATTR = 0x1D3 // 467 + SYS_TCSETPGRP = 0x1D4 // 468 + SYS_TIMES = 0x1D5 // 469 + SYS_TTYNAME = 0x1D6 // 470 + SYS_TZSET = 0x1D7 // 471 + SYS_UMASK = 0x1D8 // 472 + SYS_UMOUNT = 0x1D9 // 473 + SYS_UNAME = 0x1DA // 474 + SYS_UNLINK = 0x1DB // 475 + SYS_UTIME = 0x1DC // 476 + SYS_WAIT = 0x1DD // 477 + SYS_WAITPID = 0x1DE // 478 + SYS_WRITE = 0x1DF // 479 + SYS_CHAUDIT = 0x1E0 // 480 + SYS_FCHAUDIT = 0x1E1 // 481 + SYS_GETGROUPSBYNAME = 0x1E2 // 482 + SYS_SIGWAIT = 0x1E3 // 483 + SYS_PTHREAD_EXIT = 0x1E4 // 484 + SYS_PTHREAD_KILL = 0x1E5 // 485 + SYS_PTHREAD_ATTR_INIT = 0x1E6 // 486 + SYS_PTHREAD_ATTR_DESTROY = 0x1E7 // 487 + SYS_PTHREAD_ATTR_SETSTACKSIZE = 0x1E8 // 488 + SYS_PTHREAD_ATTR_GETSTACKSIZE = 0x1E9 // 489 + SYS_PTHREAD_ATTR_SETDETACHSTATE = 0x1EA // 490 + SYS_PTHREAD_ATTR_GETDETACHSTATE = 0x1EB // 491 + SYS_PTHREAD_ATTR_SETWEIGHT_NP = 0x1EC // 492 + SYS_PTHREAD_ATTR_GETWEIGHT_NP = 0x1ED // 493 + SYS_PTHREAD_CANCEL = 0x1EE // 494 + SYS_PTHREAD_CLEANUP_PUSH = 0x1EF // 495 + SYS_PTHREAD_CLEANUP_POP = 0x1F0 // 496 + SYS_PTHREAD_CONDATTR_INIT = 0x1F1 // 497 + SYS_PTHREAD_CONDATTR_DESTROY = 0x1F2 // 498 + SYS_PTHREAD_COND_INIT = 0x1F3 // 499 + SYS_PTHREAD_COND_DESTROY = 0x1F4 // 500 + SYS_PTHREAD_COND_SIGNAL = 0x1F5 // 501 + SYS_PTHREAD_COND_BROADCAST = 0x1F6 // 502 + SYS_PTHREAD_COND_WAIT = 0x1F7 // 503 + SYS_PTHREAD_COND_TIMEDWAIT = 0x1F8 // 504 + SYS_PTHREAD_CREATE = 0x1F9 // 505 + SYS_PTHREAD_DETACH = 0x1FA // 506 + SYS_PTHREAD_EQUAL = 0x1FB // 507 + SYS_PTHREAD_GETSPECIFIC = 0x1FC // 508 + SYS_PTHREAD_JOIN = 0x1FD // 509 + SYS_PTHREAD_KEY_CREATE = 0x1FE // 510 + SYS_PTHREAD_MUTEXATTR_INIT = 0x1FF // 511 + SYS_PTHREAD_MUTEXATTR_DESTROY = 0x200 // 512 + SYS_PTHREAD_MUTEXATTR_SETKIND_NP = 0x201 // 513 + SYS_PTHREAD_MUTEXATTR_GETKIND_NP = 0x202 // 514 + SYS_PTHREAD_MUTEX_INIT = 0x203 // 515 + SYS_PTHREAD_MUTEX_DESTROY = 0x204 // 516 + SYS_PTHREAD_MUTEX_LOCK = 0x205 // 517 + SYS_PTHREAD_MUTEX_TRYLOCK = 0x206 // 518 + SYS_PTHREAD_MUTEX_UNLOCK = 0x207 // 519 + SYS_PTHREAD_ONCE = 0x209 // 521 + SYS_PTHREAD_SELF = 0x20A // 522 + SYS_PTHREAD_SETINTR = 0x20B // 523 + SYS_PTHREAD_SETINTRTYPE = 0x20C // 524 + SYS_PTHREAD_SETSPECIFIC = 0x20D // 525 + SYS_PTHREAD_TESTINTR = 0x20E // 526 + SYS_PTHREAD_YIELD = 0x20F // 527 + SYS_TW_OPEN = 0x210 // 528 + SYS_TW_FCNTL = 0x211 // 529 + SYS_PTHREAD_JOIN_D4_NP = 0x212 // 530 + SYS_PTHREAD_CONDATTR_SETKIND_NP = 0x213 // 531 + SYS_PTHREAD_CONDATTR_GETKIND_NP = 0x214 // 532 + SYS_EXTLINK_NP = 0x215 // 533 + SYS___PASSWD = 0x216 // 534 + SYS_SETGROUPS = 0x217 // 535 + SYS_INITGROUPS = 0x218 // 536 + SYS_WCSPBRK = 0x23F // 575 + SYS_WCSRCHR = 0x240 // 576 + SYS_SVC99 = 0x241 // 577 + SYS___SVC99 = 0x241 // 577 + SYS_WCSWCS = 0x242 // 578 + SYS_LOCALECO = 0x243 // 579 + SYS_LOCALECONV = 0x243 // 579 + SYS___LIBREL = 0x244 // 580 + SYS_RELEASE = 0x245 // 581 + SYS___RLSE = 0x245 // 581 + SYS_FLOCATE = 0x246 // 582 + SYS___FLOCT = 0x246 // 582 + SYS_FDELREC = 0x247 // 583 + SYS___FDLREC = 0x247 // 583 + SYS_FETCH = 0x248 // 584 + SYS___FETCH = 0x248 // 584 + SYS_QSORT = 0x249 // 585 + SYS_GETENV = 0x24A // 586 + SYS_SYSTEM = 0x24B // 587 + SYS_BSEARCH = 0x24C // 588 + SYS_LDIV = 0x24D // 589 + SYS___THROW = 0x25E // 606 + SYS___RETHROW = 0x25F // 607 + SYS___CLEANUPCATCH = 0x260 // 608 + SYS___CATCHMATCH = 0x261 // 609 + SYS___CLEAN2UPCATCH = 0x262 // 610 + SYS_PUTENV = 0x26A // 618 + SYS___GETENV = 0x26F // 623 + SYS_GETPRIORITY = 0x270 // 624 + SYS_NICE = 0x271 // 625 + SYS_SETPRIORITY = 0x272 // 626 + SYS_GETITIMER = 0x273 // 627 + SYS_SETITIMER = 0x274 // 628 + SYS_MSGCTL = 0x275 // 629 + SYS_MSGGET = 0x276 // 630 + SYS_MSGRCV = 0x277 // 631 + SYS_MSGSND = 0x278 // 632 + SYS_MSGXRCV = 0x279 // 633 + SYS___MSGXR = 0x279 // 633 + SYS_SEMCTL = 0x27A // 634 + SYS_SEMGET = 0x27B // 635 + SYS_SEMOP = 0x27C // 636 + SYS_SHMAT = 0x27D // 637 + SYS_SHMCTL = 0x27E // 638 + SYS_SHMDT = 0x27F // 639 + SYS_SHMGET = 0x280 // 640 + SYS___GETIPC = 0x281 // 641 + SYS_SETGRENT = 0x282 // 642 + SYS_GETGRENT = 0x283 // 643 + SYS_ENDGRENT = 0x284 // 644 + SYS_SETPWENT = 0x285 // 645 + SYS_GETPWENT = 0x286 // 646 + SYS_ENDPWENT = 0x287 // 647 + SYS_BSD_SIGNAL = 0x288 // 648 + SYS_KILLPG = 0x289 // 649 + SYS_SIGALTSTACK = 0x28A // 650 + SYS_SIGHOLD = 0x28B // 651 + SYS_SIGIGNORE = 0x28C // 652 + SYS_SIGINTERRUPT = 0x28D // 653 + SYS_SIGPAUSE = 0x28E // 654 + SYS_SIGRELSE = 0x28F // 655 + SYS_SIGSET = 0x290 // 656 + SYS_SIGSTACK = 0x291 // 657 + SYS_GETRLIMIT = 0x292 // 658 + SYS_SETRLIMIT = 0x293 // 659 + SYS_GETRUSAGE = 0x294 // 660 + SYS_MMAP = 0x295 // 661 + SYS_MPROTECT = 0x296 // 662 + SYS_MSYNC = 0x297 // 663 + SYS_MUNMAP = 0x298 // 664 + SYS_CONFSTR = 0x299 // 665 + SYS_GETOPT = 0x29A // 666 + SYS_LCHOWN = 0x29B // 667 + SYS_TRUNCATE = 0x29C // 668 + SYS_GETSUBOPT = 0x29D // 669 + SYS_SETPGRP = 0x29E // 670 + SYS___GDERR = 0x29F // 671 + SYS___TZONE = 0x2A0 // 672 + SYS___DLGHT = 0x2A1 // 673 + SYS___OPARGF = 0x2A2 // 674 + SYS___OPOPTF = 0x2A3 // 675 + SYS___OPINDF = 0x2A4 // 676 + SYS___OPERRF = 0x2A5 // 677 + SYS_GETDATE = 0x2A6 // 678 + SYS_WAIT3 = 0x2A7 // 679 + SYS_WAITID = 0x2A8 // 680 + SYS___CATTRM = 0x2A9 // 681 + SYS___GDTRM = 0x2AA // 682 + SYS___RNDTRM = 0x2AB // 683 + SYS_CRYPT = 0x2AC // 684 + SYS_ENCRYPT = 0x2AD // 685 + SYS_SETKEY = 0x2AE // 686 + SYS___CNVBLK = 0x2AF // 687 + SYS___CRYTRM = 0x2B0 // 688 + SYS___ECRTRM = 0x2B1 // 689 + SYS_DRAND48 = 0x2B2 // 690 + SYS_ERAND48 = 0x2B3 // 691 + SYS_FSTATVFS = 0x2B4 // 692 + SYS_STATVFS = 0x2B5 // 693 + SYS_CATCLOSE = 0x2B6 // 694 + SYS_CATGETS = 0x2B7 // 695 + SYS_CATOPEN = 0x2B8 // 696 + SYS_BCMP = 0x2B9 // 697 + SYS_BCOPY = 0x2BA // 698 + SYS_BZERO = 0x2BB // 699 + SYS_FFS = 0x2BC // 700 + SYS_INDEX = 0x2BD // 701 + SYS_RINDEX = 0x2BE // 702 + SYS_STRCASECMP = 0x2BF // 703 + SYS_STRDUP = 0x2C0 // 704 + SYS_STRNCASECMP = 0x2C1 // 705 + SYS_INITSTATE = 0x2C2 // 706 + SYS_SETSTATE = 0x2C3 // 707 + SYS_RANDOM = 0x2C4 // 708 + SYS_SRANDOM = 0x2C5 // 709 + SYS_HCREATE = 0x2C6 // 710 + SYS_HDESTROY = 0x2C7 // 711 + SYS_HSEARCH = 0x2C8 // 712 + SYS_LFIND = 0x2C9 // 713 + SYS_LSEARCH = 0x2CA // 714 + SYS_TDELETE = 0x2CB // 715 + SYS_TFIND = 0x2CC // 716 + SYS_TSEARCH = 0x2CD // 717 + SYS_TWALK = 0x2CE // 718 + SYS_INSQUE = 0x2CF // 719 + SYS_REMQUE = 0x2D0 // 720 + SYS_POPEN = 0x2D1 // 721 + SYS_PCLOSE = 0x2D2 // 722 + SYS_SWAB = 0x2D3 // 723 + SYS_MEMCCPY = 0x2D4 // 724 + SYS_GETPAGESIZE = 0x2D8 // 728 + SYS_FCHDIR = 0x2D9 // 729 + SYS___OCLCK = 0x2DA // 730 + SYS___ATOE = 0x2DB // 731 + SYS___ATOE_L = 0x2DC // 732 + SYS___ETOA = 0x2DD // 733 + SYS___ETOA_L = 0x2DE // 734 + SYS_SETUTXENT = 0x2DF // 735 + SYS_GETUTXENT = 0x2E0 // 736 + SYS_ENDUTXENT = 0x2E1 // 737 + SYS_GETUTXID = 0x2E2 // 738 + SYS_GETUTXLINE = 0x2E3 // 739 + SYS_PUTUTXLINE = 0x2E4 // 740 + SYS_FMTMSG = 0x2E5 // 741 + SYS_JRAND48 = 0x2E6 // 742 + SYS_LRAND48 = 0x2E7 // 743 + SYS_MRAND48 = 0x2E8 // 744 + SYS_NRAND48 = 0x2E9 // 745 + SYS_LCONG48 = 0x2EA // 746 + SYS_SRAND48 = 0x2EB // 747 + SYS_SEED48 = 0x2EC // 748 + SYS_ISASCII = 0x2ED // 749 + SYS_TOASCII = 0x2EE // 750 + SYS_A64L = 0x2EF // 751 + SYS_L64A = 0x2F0 // 752 + SYS_UALARM = 0x2F1 // 753 + SYS_USLEEP = 0x2F2 // 754 + SYS___UTXTRM = 0x2F3 // 755 + SYS___SRCTRM = 0x2F4 // 756 + SYS_FTIME = 0x2F5 // 757 + SYS_GETTIMEOFDAY = 0x2F6 // 758 + SYS_DBM_CLEARERR = 0x2F7 // 759 + SYS_DBM_CLOSE = 0x2F8 // 760 + SYS_DBM_DELETE = 0x2F9 // 761 + SYS_DBM_ERROR = 0x2FA // 762 + SYS_DBM_FETCH = 0x2FB // 763 + SYS_DBM_FIRSTKEY = 0x2FC // 764 + SYS_DBM_NEXTKEY = 0x2FD // 765 + SYS_DBM_OPEN = 0x2FE // 766 + SYS_DBM_STORE = 0x2FF // 767 + SYS___NDMTRM = 0x300 // 768 + SYS_FTOK = 0x301 // 769 + SYS_BASENAME = 0x302 // 770 + SYS_DIRNAME = 0x303 // 771 + SYS_GETDTABLESIZE = 0x304 // 772 + SYS_MKSTEMP = 0x305 // 773 + SYS_MKTEMP = 0x306 // 774 + SYS_NFTW = 0x307 // 775 + SYS_GETWD = 0x308 // 776 + SYS_LOCKF = 0x309 // 777 + SYS__LONGJMP = 0x30D // 781 + SYS__SETJMP = 0x30E // 782 + SYS_VFORK = 0x30F // 783 + SYS_WORDEXP = 0x310 // 784 + SYS_WORDFREE = 0x311 // 785 + SYS_GETPGID = 0x312 // 786 + SYS_GETSID = 0x313 // 787 + SYS___UTMPXNAME = 0x314 // 788 + SYS_CUSERID = 0x315 // 789 + SYS_GETPASS = 0x316 // 790 + SYS_FNMATCH = 0x317 // 791 + SYS_FTW = 0x318 // 792 + SYS_GETW = 0x319 // 793 + SYS_GLOB = 0x31A // 794 + SYS_GLOBFREE = 0x31B // 795 + SYS_PUTW = 0x31C // 796 + SYS_SEEKDIR = 0x31D // 797 + SYS_TELLDIR = 0x31E // 798 + SYS_TEMPNAM = 0x31F // 799 + SYS_ACOSH = 0x320 // 800 + SYS_ASINH = 0x321 // 801 + SYS_ATANH = 0x322 // 802 + SYS_CBRT = 0x323 // 803 + SYS_EXPM1 = 0x324 // 804 + SYS_ILOGB = 0x325 // 805 + SYS_LOGB = 0x326 // 806 + SYS_LOG1P = 0x327 // 807 + SYS_NEXTAFTER = 0x328 // 808 + SYS_RINT = 0x329 // 809 + SYS_REMAINDER = 0x32A // 810 + SYS_SCALB = 0x32B // 811 + SYS_LGAMMA = 0x32C // 812 + SYS_TTYSLOT = 0x32D // 813 + SYS_GETTIMEOFDAY_R = 0x32E // 814 + SYS_SYNC = 0x32F // 815 + SYS_SPAWN = 0x330 // 816 + SYS_SPAWNP = 0x331 // 817 + SYS_GETLOGIN_UU = 0x332 // 818 + SYS_ECVT = 0x333 // 819 + SYS_FCVT = 0x334 // 820 + SYS_GCVT = 0x335 // 821 + SYS_ACCEPT = 0x336 // 822 + SYS_BIND = 0x337 // 823 + SYS_CONNECT = 0x338 // 824 + SYS_ENDHOSTENT = 0x339 // 825 + SYS_ENDPROTOENT = 0x33A // 826 + SYS_ENDSERVENT = 0x33B // 827 + SYS_GETHOSTBYADDR_R = 0x33C // 828 + SYS_GETHOSTBYADDR = 0x33D // 829 + SYS_GETHOSTBYNAME_R = 0x33E // 830 + SYS_GETHOSTBYNAME = 0x33F // 831 + SYS_GETHOSTENT = 0x340 // 832 + SYS_GETHOSTID = 0x341 // 833 + SYS_GETHOSTNAME = 0x342 // 834 + SYS_GETNETBYADDR = 0x343 // 835 + SYS_GETNETBYNAME = 0x344 // 836 + SYS_GETNETENT = 0x345 // 837 + SYS_GETPEERNAME = 0x346 // 838 + SYS_GETPROTOBYNAME = 0x347 // 839 + SYS_GETPROTOBYNUMBER = 0x348 // 840 + SYS_GETPROTOENT = 0x349 // 841 + SYS_GETSERVBYNAME = 0x34A // 842 + SYS_GETSERVBYPORT = 0x34B // 843 + SYS_GETSERVENT = 0x34C // 844 + SYS_GETSOCKNAME = 0x34D // 845 + SYS_GETSOCKOPT = 0x34E // 846 + SYS_INET_ADDR = 0x34F // 847 + SYS_INET_LNAOF = 0x350 // 848 + SYS_INET_MAKEADDR = 0x351 // 849 + SYS_INET_NETOF = 0x352 // 850 + SYS_INET_NETWORK = 0x353 // 851 + SYS_INET_NTOA = 0x354 // 852 + SYS_IOCTL = 0x355 // 853 + SYS_LISTEN = 0x356 // 854 + SYS_READV = 0x357 // 855 + SYS_RECV = 0x358 // 856 + SYS_RECVFROM = 0x359 // 857 + SYS_SELECT = 0x35B // 859 + SYS_SELECTEX = 0x35C // 860 + SYS_SEND = 0x35D // 861 + SYS_SENDTO = 0x35F // 863 + SYS_SETHOSTENT = 0x360 // 864 + SYS_SETNETENT = 0x361 // 865 + SYS_SETPEER = 0x362 // 866 + SYS_SETPROTOENT = 0x363 // 867 + SYS_SETSERVENT = 0x364 // 868 + SYS_SETSOCKOPT = 0x365 // 869 + SYS_SHUTDOWN = 0x366 // 870 + SYS_SOCKET = 0x367 // 871 + SYS_SOCKETPAIR = 0x368 // 872 + SYS_WRITEV = 0x369 // 873 + SYS_CHROOT = 0x36A // 874 + SYS_W_STATVFS = 0x36B // 875 + SYS_ULIMIT = 0x36C // 876 + SYS_ISNAN = 0x36D // 877 + SYS_UTIMES = 0x36E // 878 + SYS___H_ERRNO = 0x36F // 879 + SYS_ENDNETENT = 0x370 // 880 + SYS_CLOSELOG = 0x371 // 881 + SYS_OPENLOG = 0x372 // 882 + SYS_SETLOGMASK = 0x373 // 883 + SYS_SYSLOG = 0x374 // 884 + SYS_PTSNAME = 0x375 // 885 + SYS_SETREUID = 0x376 // 886 + SYS_SETREGID = 0x377 // 887 + SYS_REALPATH = 0x378 // 888 + SYS___SIGNGAM = 0x379 // 889 + SYS_GRANTPT = 0x37A // 890 + SYS_UNLOCKPT = 0x37B // 891 + SYS_TCGETSID = 0x37C // 892 + SYS___TCGETCP = 0x37D // 893 + SYS___TCSETCP = 0x37E // 894 + SYS___TCSETTABLES = 0x37F // 895 + SYS_POLL = 0x380 // 896 + SYS_REXEC = 0x381 // 897 + SYS___ISASCII2 = 0x382 // 898 + SYS___TOASCII2 = 0x383 // 899 + SYS_CHPRIORITY = 0x384 // 900 + SYS_PTHREAD_ATTR_SETSYNCTYPE_NP = 0x385 // 901 + SYS_PTHREAD_ATTR_GETSYNCTYPE_NP = 0x386 // 902 + SYS_PTHREAD_SET_LIMIT_NP = 0x387 // 903 + SYS___STNETENT = 0x388 // 904 + SYS___STPROTOENT = 0x389 // 905 + SYS___STSERVENT = 0x38A // 906 + SYS___STHOSTENT = 0x38B // 907 + SYS_NLIST = 0x38C // 908 + SYS___IPDBCS = 0x38D // 909 + SYS___IPDSPX = 0x38E // 910 + SYS___IPMSGC = 0x38F // 911 + SYS___SELECT1 = 0x390 // 912 + SYS_PTHREAD_SECURITY_NP = 0x391 // 913 + SYS___CHECK_RESOURCE_AUTH_NP = 0x392 // 914 + SYS___CONVERT_ID_NP = 0x393 // 915 + SYS___OPENVMREL = 0x394 // 916 + SYS_WMEMCHR = 0x395 // 917 + SYS_WMEMCMP = 0x396 // 918 + SYS_WMEMCPY = 0x397 // 919 + SYS_WMEMMOVE = 0x398 // 920 + SYS_WMEMSET = 0x399 // 921 + SYS___FPUTWC = 0x400 // 1024 + SYS___PUTWC = 0x401 // 1025 + SYS___PWCHAR = 0x402 // 1026 + SYS___WCSFTM = 0x403 // 1027 + SYS___WCSTOK = 0x404 // 1028 + SYS___WCWDTH = 0x405 // 1029 + SYS_T_ACCEPT = 0x409 // 1033 + SYS_T_ALLOC = 0x40A // 1034 + SYS_T_BIND = 0x40B // 1035 + SYS_T_CLOSE = 0x40C // 1036 + SYS_T_CONNECT = 0x40D // 1037 + SYS_T_ERROR = 0x40E // 1038 + SYS_T_FREE = 0x40F // 1039 + SYS_T_GETINFO = 0x410 // 1040 + SYS_T_GETPROTADDR = 0x411 // 1041 + SYS_T_GETSTATE = 0x412 // 1042 + SYS_T_LISTEN = 0x413 // 1043 + SYS_T_LOOK = 0x414 // 1044 + SYS_T_OPEN = 0x415 // 1045 + SYS_T_OPTMGMT = 0x416 // 1046 + SYS_T_RCV = 0x417 // 1047 + SYS_T_RCVCONNECT = 0x418 // 1048 + SYS_T_RCVDIS = 0x419 // 1049 + SYS_T_RCVREL = 0x41A // 1050 + SYS_T_RCVUDATA = 0x41B // 1051 + SYS_T_RCVUDERR = 0x41C // 1052 + SYS_T_SND = 0x41D // 1053 + SYS_T_SNDDIS = 0x41E // 1054 + SYS_T_SNDREL = 0x41F // 1055 + SYS_T_SNDUDATA = 0x420 // 1056 + SYS_T_STRERROR = 0x421 // 1057 + SYS_T_SYNC = 0x422 // 1058 + SYS_T_UNBIND = 0x423 // 1059 + SYS___T_ERRNO = 0x424 // 1060 + SYS___RECVMSG2 = 0x425 // 1061 + SYS___SENDMSG2 = 0x426 // 1062 + SYS_FATTACH = 0x427 // 1063 + SYS_FDETACH = 0x428 // 1064 + SYS_GETMSG = 0x429 // 1065 + SYS_GETPMSG = 0x42A // 1066 + SYS_ISASTREAM = 0x42B // 1067 + SYS_PUTMSG = 0x42C // 1068 + SYS_PUTPMSG = 0x42D // 1069 + SYS___ISPOSIXON = 0x42E // 1070 + SYS___OPENMVSREL = 0x42F // 1071 + SYS_GETCONTEXT = 0x430 // 1072 + SYS_SETCONTEXT = 0x431 // 1073 + SYS_MAKECONTEXT = 0x432 // 1074 + SYS_SWAPCONTEXT = 0x433 // 1075 + SYS_PTHREAD_GETSPECIFIC_D8_NP = 0x434 // 1076 + SYS_GETCLIENTID = 0x470 // 1136 + SYS___GETCLIENTID = 0x471 // 1137 + SYS_GETSTABLESIZE = 0x472 // 1138 + SYS_GETIBMOPT = 0x473 // 1139 + SYS_GETIBMSOCKOPT = 0x474 // 1140 + SYS_GIVESOCKET = 0x475 // 1141 + SYS_IBMSFLUSH = 0x476 // 1142 + SYS_MAXDESC = 0x477 // 1143 + SYS_SETIBMOPT = 0x478 // 1144 + SYS_SETIBMSOCKOPT = 0x479 // 1145 + SYS_SOCK_DEBUG = 0x47A // 1146 + SYS_SOCK_DO_TESTSTOR = 0x47D // 1149 + SYS_TAKESOCKET = 0x47E // 1150 + SYS___SERVER_INIT = 0x47F // 1151 + SYS___SERVER_PWU = 0x480 // 1152 + SYS_PTHREAD_TAG_NP = 0x481 // 1153 + SYS___CONSOLE = 0x482 // 1154 + SYS___WSINIT = 0x483 // 1155 + SYS___IPTCPN = 0x489 // 1161 + SYS___SMF_RECORD = 0x48A // 1162 + SYS___IPHOST = 0x48B // 1163 + SYS___IPNODE = 0x48C // 1164 + SYS___SERVER_CLASSIFY_CREATE = 0x48D // 1165 + SYS___SERVER_CLASSIFY_DESTROY = 0x48E // 1166 + SYS___SERVER_CLASSIFY_RESET = 0x48F // 1167 + SYS___SERVER_CLASSIFY = 0x490 // 1168 + SYS___HEAPRPT = 0x496 // 1174 + SYS___FNWSA = 0x49B // 1179 + SYS___SPAWN2 = 0x49D // 1181 + SYS___SPAWNP2 = 0x49E // 1182 + SYS___GDRR = 0x4A1 // 1185 + SYS___HRRNO = 0x4A2 // 1186 + SYS___OPRG = 0x4A3 // 1187 + SYS___OPRR = 0x4A4 // 1188 + SYS___OPND = 0x4A5 // 1189 + SYS___OPPT = 0x4A6 // 1190 + SYS___SIGGM = 0x4A7 // 1191 + SYS___DGHT = 0x4A8 // 1192 + SYS___TZNE = 0x4A9 // 1193 + SYS___TZZN = 0x4AA // 1194 + SYS___TRRNO = 0x4AF // 1199 + SYS___ENVN = 0x4B0 // 1200 + SYS___MLOCKALL = 0x4B1 // 1201 + SYS_CREATEWO = 0x4B2 // 1202 + SYS_CREATEWORKUNIT = 0x4B2 // 1202 + SYS_CONTINUE = 0x4B3 // 1203 + SYS_CONTINUEWORKUNIT = 0x4B3 // 1203 + SYS_CONNECTW = 0x4B4 // 1204 + SYS_CONNECTWORKMGR = 0x4B4 // 1204 + SYS_CONNECTS = 0x4B5 // 1205 + SYS_CONNECTSERVER = 0x4B5 // 1205 + SYS_DISCONNE = 0x4B6 // 1206 + SYS_DISCONNECTSERVER = 0x4B6 // 1206 + SYS_JOINWORK = 0x4B7 // 1207 + SYS_JOINWORKUNIT = 0x4B7 // 1207 + SYS_LEAVEWOR = 0x4B8 // 1208 + SYS_LEAVEWORKUNIT = 0x4B8 // 1208 + SYS_DELETEWO = 0x4B9 // 1209 + SYS_DELETEWORKUNIT = 0x4B9 // 1209 + SYS_QUERYMET = 0x4BA // 1210 + SYS_QUERYMETRICS = 0x4BA // 1210 + SYS_QUERYSCH = 0x4BB // 1211 + SYS_QUERYSCHENV = 0x4BB // 1211 + SYS_CHECKSCH = 0x4BC // 1212 + SYS_CHECKSCHENV = 0x4BC // 1212 + SYS___PID_AFFINITY = 0x4BD // 1213 + SYS___ASINH_B = 0x4BE // 1214 + SYS___ATAN_B = 0x4BF // 1215 + SYS___CBRT_B = 0x4C0 // 1216 + SYS___CEIL_B = 0x4C1 // 1217 + SYS_COPYSIGN = 0x4C2 // 1218 + SYS___COS_B = 0x4C3 // 1219 + SYS___ERF_B = 0x4C4 // 1220 + SYS___ERFC_B = 0x4C5 // 1221 + SYS___EXPM1_B = 0x4C6 // 1222 + SYS___FABS_B = 0x4C7 // 1223 + SYS_FINITE = 0x4C8 // 1224 + SYS___FLOOR_B = 0x4C9 // 1225 + SYS___FREXP_B = 0x4CA // 1226 + SYS___ILOGB_B = 0x4CB // 1227 + SYS___ISNAN_B = 0x4CC // 1228 + SYS___LDEXP_B = 0x4CD // 1229 + SYS___LOG1P_B = 0x4CE // 1230 + SYS___LOGB_B = 0x4CF // 1231 + SYS_MATHERR = 0x4D0 // 1232 + SYS___MODF_B = 0x4D1 // 1233 + SYS___NEXTAFTER_B = 0x4D2 // 1234 + SYS___RINT_B = 0x4D3 // 1235 + SYS_SCALBN = 0x4D4 // 1236 + SYS_SIGNIFIC = 0x4D5 // 1237 + SYS_SIGNIFICAND = 0x4D5 // 1237 + SYS___SIN_B = 0x4D6 // 1238 + SYS___TAN_B = 0x4D7 // 1239 + SYS___TANH_B = 0x4D8 // 1240 + SYS___ACOS_B = 0x4D9 // 1241 + SYS___ACOSH_B = 0x4DA // 1242 + SYS___ASIN_B = 0x4DB // 1243 + SYS___ATAN2_B = 0x4DC // 1244 + SYS___ATANH_B = 0x4DD // 1245 + SYS___COSH_B = 0x4DE // 1246 + SYS___EXP_B = 0x4DF // 1247 + SYS___FMOD_B = 0x4E0 // 1248 + SYS___GAMMA_B = 0x4E1 // 1249 + SYS_GAMMA_R = 0x4E2 // 1250 + SYS___HYPOT_B = 0x4E3 // 1251 + SYS___J0_B = 0x4E4 // 1252 + SYS___Y0_B = 0x4E5 // 1253 + SYS___J1_B = 0x4E6 // 1254 + SYS___Y1_B = 0x4E7 // 1255 + SYS___JN_B = 0x4E8 // 1256 + SYS___YN_B = 0x4E9 // 1257 + SYS___LGAMMA_B = 0x4EA // 1258 + SYS_LGAMMA_R = 0x4EB // 1259 + SYS___LOG_B = 0x4EC // 1260 + SYS___LOG10_B = 0x4ED // 1261 + SYS___POW_B = 0x4EE // 1262 + SYS___REMAINDER_B = 0x4EF // 1263 + SYS___SCALB_B = 0x4F0 // 1264 + SYS___SINH_B = 0x4F1 // 1265 + SYS___SQRT_B = 0x4F2 // 1266 + SYS___OPENDIR2 = 0x4F3 // 1267 + SYS___READDIR2 = 0x4F4 // 1268 + SYS___LOGIN = 0x4F5 // 1269 + SYS___OPEN_STAT = 0x4F6 // 1270 + SYS_ACCEPT_AND_RECV = 0x4F7 // 1271 + SYS___FP_SETMODE = 0x4F8 // 1272 + SYS___SIGACTIONSET = 0x4FB // 1275 + SYS___UCREATE = 0x4FC // 1276 + SYS___UMALLOC = 0x4FD // 1277 + SYS___UFREE = 0x4FE // 1278 + SYS___UHEAPREPORT = 0x4FF // 1279 + SYS___ISBFP = 0x500 // 1280 + SYS___FP_CAST = 0x501 // 1281 + SYS___CERTIFICATE = 0x502 // 1282 + SYS_SEND_FILE = 0x503 // 1283 + SYS_AIO_CANCEL = 0x504 // 1284 + SYS_AIO_ERROR = 0x505 // 1285 + SYS_AIO_READ = 0x506 // 1286 + SYS_AIO_RETURN = 0x507 // 1287 + SYS_AIO_SUSPEND = 0x508 // 1288 + SYS_AIO_WRITE = 0x509 // 1289 + SYS_PTHREAD_MUTEXATTR_GETPSHARED = 0x50A // 1290 + SYS_PTHREAD_MUTEXATTR_SETPSHARED = 0x50B // 1291 + SYS_PTHREAD_RWLOCK_DESTROY = 0x50C // 1292 + SYS_PTHREAD_RWLOCK_INIT = 0x50D // 1293 + SYS_PTHREAD_RWLOCK_RDLOCK = 0x50E // 1294 + SYS_PTHREAD_RWLOCK_TRYRDLOCK = 0x50F // 1295 + SYS_PTHREAD_RWLOCK_TRYWRLOCK = 0x510 // 1296 + SYS_PTHREAD_RWLOCK_UNLOCK = 0x511 // 1297 + SYS_PTHREAD_RWLOCK_WRLOCK = 0x512 // 1298 + SYS_PTHREAD_RWLOCKATTR_GETPSHARED = 0x513 // 1299 + SYS_PTHREAD_RWLOCKATTR_SETPSHARED = 0x514 // 1300 + SYS_PTHREAD_RWLOCKATTR_INIT = 0x515 // 1301 + SYS_PTHREAD_RWLOCKATTR_DESTROY = 0x516 // 1302 + SYS___CTTBL = 0x517 // 1303 + SYS_PTHREAD_MUTEXATTR_SETTYPE = 0x518 // 1304 + SYS_PTHREAD_MUTEXATTR_GETTYPE = 0x519 // 1305 + SYS___FP_CLR_FLAG = 0x51A // 1306 + SYS___FP_READ_FLAG = 0x51B // 1307 + SYS___FP_RAISE_XCP = 0x51C // 1308 + SYS___FP_CLASS = 0x51D // 1309 + SYS___FP_FINITE = 0x51E // 1310 + SYS___FP_ISNAN = 0x51F // 1311 + SYS___FP_UNORDERED = 0x520 // 1312 + SYS___FP_READ_RND = 0x521 // 1313 + SYS___FP_READ_RND_B = 0x522 // 1314 + SYS___FP_SWAP_RND = 0x523 // 1315 + SYS___FP_SWAP_RND_B = 0x524 // 1316 + SYS___FP_LEVEL = 0x525 // 1317 + SYS___FP_BTOH = 0x526 // 1318 + SYS___FP_HTOB = 0x527 // 1319 + SYS___FPC_RD = 0x528 // 1320 + SYS___FPC_WR = 0x529 // 1321 + SYS___FPC_RW = 0x52A // 1322 + SYS___FPC_SM = 0x52B // 1323 + SYS___FPC_RS = 0x52C // 1324 + SYS_SIGTIMEDWAIT = 0x52D // 1325 + SYS_SIGWAITINFO = 0x52E // 1326 + SYS___CHKBFP = 0x52F // 1327 + SYS___W_PIOCTL = 0x59E // 1438 + SYS___OSENV = 0x59F // 1439 + SYS_EXPORTWO = 0x5A1 // 1441 + SYS_EXPORTWORKUNIT = 0x5A1 // 1441 + SYS_UNDOEXPO = 0x5A2 // 1442 + SYS_UNDOEXPORTWORKUNIT = 0x5A2 // 1442 + SYS_IMPORTWO = 0x5A3 // 1443 + SYS_IMPORTWORKUNIT = 0x5A3 // 1443 + SYS_UNDOIMPO = 0x5A4 // 1444 + SYS_UNDOIMPORTWORKUNIT = 0x5A4 // 1444 + SYS_EXTRACTW = 0x5A5 // 1445 + SYS_EXTRACTWORKUNIT = 0x5A5 // 1445 + SYS___CPL = 0x5A6 // 1446 + SYS___MAP_INIT = 0x5A7 // 1447 + SYS___MAP_SERVICE = 0x5A8 // 1448 + SYS_SIGQUEUE = 0x5A9 // 1449 + SYS___MOUNT = 0x5AA // 1450 + SYS___GETUSERID = 0x5AB // 1451 + SYS___IPDOMAINNAME = 0x5AC // 1452 + SYS_QUERYENC = 0x5AD // 1453 + SYS_QUERYWORKUNITCLASSIFICATION = 0x5AD // 1453 + SYS_CONNECTE = 0x5AE // 1454 + SYS_CONNECTEXPORTIMPORT = 0x5AE // 1454 + SYS___FP_SWAPMODE = 0x5AF // 1455 + SYS_STRTOLL = 0x5B0 // 1456 + SYS_STRTOULL = 0x5B1 // 1457 + SYS___DSA_PREV = 0x5B2 // 1458 + SYS___EP_FIND = 0x5B3 // 1459 + SYS___SERVER_THREADS_QUERY = 0x5B4 // 1460 + SYS___MSGRCV_TIMED = 0x5B7 // 1463 + SYS___SEMOP_TIMED = 0x5B8 // 1464 + SYS___GET_CPUID = 0x5B9 // 1465 + SYS___GET_SYSTEM_SETTINGS = 0x5BA // 1466 + SYS_FTELLO = 0x5C8 // 1480 + SYS_FSEEKO = 0x5C9 // 1481 + SYS_LLDIV = 0x5CB // 1483 + SYS_WCSTOLL = 0x5CC // 1484 + SYS_WCSTOULL = 0x5CD // 1485 + SYS_LLABS = 0x5CE // 1486 + SYS___CONSOLE2 = 0x5D2 // 1490 + SYS_INET_NTOP = 0x5D3 // 1491 + SYS_INET_PTON = 0x5D4 // 1492 + SYS___RES = 0x5D6 // 1494 + SYS_RES_MKQUERY = 0x5D7 // 1495 + SYS_RES_INIT = 0x5D8 // 1496 + SYS_RES_QUERY = 0x5D9 // 1497 + SYS_RES_SEARCH = 0x5DA // 1498 + SYS_RES_SEND = 0x5DB // 1499 + SYS_RES_QUERYDOMAIN = 0x5DC // 1500 + SYS_DN_EXPAND = 0x5DD // 1501 + SYS_DN_SKIPNAME = 0x5DE // 1502 + SYS_DN_COMP = 0x5DF // 1503 + SYS_ASCTIME_R = 0x5E0 // 1504 + SYS_CTIME_R = 0x5E1 // 1505 + SYS_GMTIME_R = 0x5E2 // 1506 + SYS_LOCALTIME_R = 0x5E3 // 1507 + SYS_RAND_R = 0x5E4 // 1508 + SYS_STRTOK_R = 0x5E5 // 1509 + SYS_READDIR_R = 0x5E6 // 1510 + SYS_GETGRGID_R = 0x5E7 // 1511 + SYS_GETGRNAM_R = 0x5E8 // 1512 + SYS_GETLOGIN_R = 0x5E9 // 1513 + SYS_GETPWNAM_R = 0x5EA // 1514 + SYS_GETPWUID_R = 0x5EB // 1515 + SYS_TTYNAME_R = 0x5EC // 1516 + SYS_PTHREAD_ATFORK = 0x5ED // 1517 + SYS_PTHREAD_ATTR_GETGUARDSIZE = 0x5EE // 1518 + SYS_PTHREAD_ATTR_GETSTACKADDR = 0x5EF // 1519 + SYS_PTHREAD_ATTR_SETGUARDSIZE = 0x5F0 // 1520 + SYS_PTHREAD_ATTR_SETSTACKADDR = 0x5F1 // 1521 + SYS_PTHREAD_CONDATTR_GETPSHARED = 0x5F2 // 1522 + SYS_PTHREAD_CONDATTR_SETPSHARED = 0x5F3 // 1523 + SYS_PTHREAD_GETCONCURRENCY = 0x5F4 // 1524 + SYS_PTHREAD_KEY_DELETE = 0x5F5 // 1525 + SYS_PTHREAD_SETCONCURRENCY = 0x5F6 // 1526 + SYS_PTHREAD_SIGMASK = 0x5F7 // 1527 + SYS___DISCARDDATA = 0x5F8 // 1528 + SYS_PTHREAD_ATTR_GETSCHEDPARAM = 0x5F9 // 1529 + SYS_PTHREAD_ATTR_SETSCHEDPARAM = 0x5FA // 1530 + SYS_PTHREAD_ATTR_GETDETACHSTATE_U98 = 0x5FB // 1531 + SYS_PTHREAD_ATTR_SETDETACHSTATE_U98 = 0x5FC // 1532 + SYS_PTHREAD_DETACH_U98 = 0x5FD // 1533 + SYS_PTHREAD_GETSPECIFIC_U98 = 0x5FE // 1534 + SYS_PTHREAD_SETCANCELSTATE = 0x5FF // 1535 + SYS_PTHREAD_SETCANCELTYPE = 0x600 // 1536 + SYS_PTHREAD_TESTCANCEL = 0x601 // 1537 + SYS___ATANF_B = 0x602 // 1538 + SYS___ATANL_B = 0x603 // 1539 + SYS___CEILF_B = 0x604 // 1540 + SYS___CEILL_B = 0x605 // 1541 + SYS___COSF_B = 0x606 // 1542 + SYS___COSL_B = 0x607 // 1543 + SYS___FABSF_B = 0x608 // 1544 + SYS___FABSL_B = 0x609 // 1545 + SYS___FLOORF_B = 0x60A // 1546 + SYS___FLOORL_B = 0x60B // 1547 + SYS___FREXPF_B = 0x60C // 1548 + SYS___FREXPL_B = 0x60D // 1549 + SYS___LDEXPF_B = 0x60E // 1550 + SYS___LDEXPL_B = 0x60F // 1551 + SYS___SINF_B = 0x610 // 1552 + SYS___SINL_B = 0x611 // 1553 + SYS___TANF_B = 0x612 // 1554 + SYS___TANL_B = 0x613 // 1555 + SYS___TANHF_B = 0x614 // 1556 + SYS___TANHL_B = 0x615 // 1557 + SYS___ACOSF_B = 0x616 // 1558 + SYS___ACOSL_B = 0x617 // 1559 + SYS___ASINF_B = 0x618 // 1560 + SYS___ASINL_B = 0x619 // 1561 + SYS___ATAN2F_B = 0x61A // 1562 + SYS___ATAN2L_B = 0x61B // 1563 + SYS___COSHF_B = 0x61C // 1564 + SYS___COSHL_B = 0x61D // 1565 + SYS___EXPF_B = 0x61E // 1566 + SYS___EXPL_B = 0x61F // 1567 + SYS___LOGF_B = 0x620 // 1568 + SYS___LOGL_B = 0x621 // 1569 + SYS___LOG10F_B = 0x622 // 1570 + SYS___LOG10L_B = 0x623 // 1571 + SYS___POWF_B = 0x624 // 1572 + SYS___POWL_B = 0x625 // 1573 + SYS___SINHF_B = 0x626 // 1574 + SYS___SINHL_B = 0x627 // 1575 + SYS___SQRTF_B = 0x628 // 1576 + SYS___SQRTL_B = 0x629 // 1577 + SYS___ABSF_B = 0x62A // 1578 + SYS___ABS_B = 0x62B // 1579 + SYS___ABSL_B = 0x62C // 1580 + SYS___FMODF_B = 0x62D // 1581 + SYS___FMODL_B = 0x62E // 1582 + SYS___MODFF_B = 0x62F // 1583 + SYS___MODFL_B = 0x630 // 1584 + SYS_ABSF = 0x631 // 1585 + SYS_ABSL = 0x632 // 1586 + SYS_ACOSF = 0x633 // 1587 + SYS_ACOSL = 0x634 // 1588 + SYS_ASINF = 0x635 // 1589 + SYS_ASINL = 0x636 // 1590 + SYS_ATAN2F = 0x637 // 1591 + SYS_ATAN2L = 0x638 // 1592 + SYS_ATANF = 0x639 // 1593 + SYS_ATANL = 0x63A // 1594 + SYS_CEILF = 0x63B // 1595 + SYS_CEILL = 0x63C // 1596 + SYS_COSF = 0x63D // 1597 + SYS_COSL = 0x63E // 1598 + SYS_COSHF = 0x63F // 1599 + SYS_COSHL = 0x640 // 1600 + SYS_EXPF = 0x641 // 1601 + SYS_EXPL = 0x642 // 1602 + SYS_TANHF = 0x643 // 1603 + SYS_TANHL = 0x644 // 1604 + SYS_LOG10F = 0x645 // 1605 + SYS_LOG10L = 0x646 // 1606 + SYS_LOGF = 0x647 // 1607 + SYS_LOGL = 0x648 // 1608 + SYS_POWF = 0x649 // 1609 + SYS_POWL = 0x64A // 1610 + SYS_SINF = 0x64B // 1611 + SYS_SINL = 0x64C // 1612 + SYS_SQRTF = 0x64D // 1613 + SYS_SQRTL = 0x64E // 1614 + SYS_SINHF = 0x64F // 1615 + SYS_SINHL = 0x650 // 1616 + SYS_TANF = 0x651 // 1617 + SYS_TANL = 0x652 // 1618 + SYS_FABSF = 0x653 // 1619 + SYS_FABSL = 0x654 // 1620 + SYS_FLOORF = 0x655 // 1621 + SYS_FLOORL = 0x656 // 1622 + SYS_FMODF = 0x657 // 1623 + SYS_FMODL = 0x658 // 1624 + SYS_FREXPF = 0x659 // 1625 + SYS_FREXPL = 0x65A // 1626 + SYS_LDEXPF = 0x65B // 1627 + SYS_LDEXPL = 0x65C // 1628 + SYS_MODFF = 0x65D // 1629 + SYS_MODFL = 0x65E // 1630 + SYS_BTOWC = 0x65F // 1631 + SYS___CHATTR = 0x660 // 1632 + SYS___FCHATTR = 0x661 // 1633 + SYS___TOCCSID = 0x662 // 1634 + SYS___CSNAMETYPE = 0x663 // 1635 + SYS___TOCSNAME = 0x664 // 1636 + SYS___CCSIDTYPE = 0x665 // 1637 + SYS___AE_CORRESTBL_QUERY = 0x666 // 1638 + SYS___AE_AUTOCONVERT_STATE = 0x667 // 1639 + SYS_DN_FIND = 0x668 // 1640 + SYS___GETHOSTBYADDR_A = 0x669 // 1641 + SYS___GETHOSTBYNAME_A = 0x66A // 1642 + SYS___RES_INIT_A = 0x66B // 1643 + SYS___GETHOSTBYADDR_R_A = 0x66C // 1644 + SYS___GETHOSTBYNAME_R_A = 0x66D // 1645 + SYS___CHARMAP_INIT_A = 0x66E // 1646 + SYS___MBLEN_A = 0x66F // 1647 + SYS___MBLEN_SB_A = 0x670 // 1648 + SYS___MBLEN_STD_A = 0x671 // 1649 + SYS___MBLEN_UTF = 0x672 // 1650 + SYS___MBSTOWCS_A = 0x673 // 1651 + SYS___MBSTOWCS_STD_A = 0x674 // 1652 + SYS___MBTOWC_A = 0x675 // 1653 + SYS___MBTOWC_ISO1 = 0x676 // 1654 + SYS___MBTOWC_SBCS = 0x677 // 1655 + SYS___MBTOWC_MBCS = 0x678 // 1656 + SYS___MBTOWC_UTF = 0x679 // 1657 + SYS___WCSTOMBS_A = 0x67A // 1658 + SYS___WCSTOMBS_STD_A = 0x67B // 1659 + SYS___WCSWIDTH_A = 0x67C // 1660 + SYS___GETGRGID_R_A = 0x67D // 1661 + SYS___WCSWIDTH_STD_A = 0x67E // 1662 + SYS___WCSWIDTH_ASIA = 0x67F // 1663 + SYS___CSID_A = 0x680 // 1664 + SYS___CSID_STD_A = 0x681 // 1665 + SYS___WCSID_A = 0x682 // 1666 + SYS___WCSID_STD_A = 0x683 // 1667 + SYS___WCTOMB_A = 0x684 // 1668 + SYS___WCTOMB_ISO1 = 0x685 // 1669 + SYS___WCTOMB_STD_A = 0x686 // 1670 + SYS___WCTOMB_UTF = 0x687 // 1671 + SYS___WCWIDTH_A = 0x688 // 1672 + SYS___GETGRNAM_R_A = 0x689 // 1673 + SYS___WCWIDTH_STD_A = 0x68A // 1674 + SYS___WCWIDTH_ASIA = 0x68B // 1675 + SYS___GETPWNAM_R_A = 0x68C // 1676 + SYS___GETPWUID_R_A = 0x68D // 1677 + SYS___GETLOGIN_R_A = 0x68E // 1678 + SYS___TTYNAME_R_A = 0x68F // 1679 + SYS___READDIR_R_A = 0x690 // 1680 + SYS___E2A_S = 0x691 // 1681 + SYS___FNMATCH_A = 0x692 // 1682 + SYS___FNMATCH_C_A = 0x693 // 1683 + SYS___EXECL_A = 0x694 // 1684 + SYS___FNMATCH_STD_A = 0x695 // 1685 + SYS___REGCOMP_A = 0x696 // 1686 + SYS___REGCOMP_STD_A = 0x697 // 1687 + SYS___REGERROR_A = 0x698 // 1688 + SYS___REGERROR_STD_A = 0x699 // 1689 + SYS___REGEXEC_A = 0x69A // 1690 + SYS___REGEXEC_STD_A = 0x69B // 1691 + SYS___REGFREE_A = 0x69C // 1692 + SYS___REGFREE_STD_A = 0x69D // 1693 + SYS___STRCOLL_A = 0x69E // 1694 + SYS___STRCOLL_C_A = 0x69F // 1695 + SYS___EXECLE_A = 0x6A0 // 1696 + SYS___STRCOLL_STD_A = 0x6A1 // 1697 + SYS___STRXFRM_A = 0x6A2 // 1698 + SYS___STRXFRM_C_A = 0x6A3 // 1699 + SYS___EXECLP_A = 0x6A4 // 1700 + SYS___STRXFRM_STD_A = 0x6A5 // 1701 + SYS___WCSCOLL_A = 0x6A6 // 1702 + SYS___WCSCOLL_C_A = 0x6A7 // 1703 + SYS___WCSCOLL_STD_A = 0x6A8 // 1704 + SYS___WCSXFRM_A = 0x6A9 // 1705 + SYS___WCSXFRM_C_A = 0x6AA // 1706 + SYS___WCSXFRM_STD_A = 0x6AB // 1707 + SYS___COLLATE_INIT_A = 0x6AC // 1708 + SYS___WCTYPE_A = 0x6AD // 1709 + SYS___GET_WCTYPE_STD_A = 0x6AE // 1710 + SYS___CTYPE_INIT_A = 0x6AF // 1711 + SYS___ISWCTYPE_A = 0x6B0 // 1712 + SYS___EXECV_A = 0x6B1 // 1713 + SYS___IS_WCTYPE_STD_A = 0x6B2 // 1714 + SYS___TOWLOWER_A = 0x6B3 // 1715 + SYS___TOWLOWER_STD_A = 0x6B4 // 1716 + SYS___TOWUPPER_A = 0x6B5 // 1717 + SYS___TOWUPPER_STD_A = 0x6B6 // 1718 + SYS___LOCALE_INIT_A = 0x6B7 // 1719 + SYS___LOCALECONV_A = 0x6B8 // 1720 + SYS___LOCALECONV_STD_A = 0x6B9 // 1721 + SYS___NL_LANGINFO_A = 0x6BA // 1722 + SYS___NL_LNAGINFO_STD_A = 0x6BB // 1723 + SYS___MONETARY_INIT_A = 0x6BC // 1724 + SYS___STRFMON_A = 0x6BD // 1725 + SYS___STRFMON_STD_A = 0x6BE // 1726 + SYS___GETADDRINFO_A = 0x6BF // 1727 + SYS___CATGETS_A = 0x6C0 // 1728 + SYS___EXECVE_A = 0x6C1 // 1729 + SYS___EXECVP_A = 0x6C2 // 1730 + SYS___SPAWN_A = 0x6C3 // 1731 + SYS___GETNAMEINFO_A = 0x6C4 // 1732 + SYS___SPAWNP_A = 0x6C5 // 1733 + SYS___NUMERIC_INIT_A = 0x6C6 // 1734 + SYS___RESP_INIT_A = 0x6C7 // 1735 + SYS___RPMATCH_A = 0x6C8 // 1736 + SYS___RPMATCH_C_A = 0x6C9 // 1737 + SYS___RPMATCH_STD_A = 0x6CA // 1738 + SYS___TIME_INIT_A = 0x6CB // 1739 + SYS___STRFTIME_A = 0x6CC // 1740 + SYS___STRFTIME_STD_A = 0x6CD // 1741 + SYS___STRPTIME_A = 0x6CE // 1742 + SYS___STRPTIME_STD_A = 0x6CF // 1743 + SYS___WCSFTIME_A = 0x6D0 // 1744 + SYS___WCSFTIME_STD_A = 0x6D1 // 1745 + SYS_____SPAWN2_A = 0x6D2 // 1746 + SYS_____SPAWNP2_A = 0x6D3 // 1747 + SYS___SYNTAX_INIT_A = 0x6D4 // 1748 + SYS___TOD_INIT_A = 0x6D5 // 1749 + SYS___NL_CSINFO_A = 0x6D6 // 1750 + SYS___NL_MONINFO_A = 0x6D7 // 1751 + SYS___NL_NUMINFO_A = 0x6D8 // 1752 + SYS___NL_RESPINFO_A = 0x6D9 // 1753 + SYS___NL_TIMINFO_A = 0x6DA // 1754 + SYS___IF_NAMETOINDEX_A = 0x6DB // 1755 + SYS___IF_INDEXTONAME_A = 0x6DC // 1756 + SYS___PRINTF_A = 0x6DD // 1757 + SYS___ICONV_OPEN_A = 0x6DE // 1758 + SYS___DLLLOAD_A = 0x6DF // 1759 + SYS___DLLQUERYFN_A = 0x6E0 // 1760 + SYS___DLLQUERYVAR_A = 0x6E1 // 1761 + SYS_____CHATTR_A = 0x6E2 // 1762 + SYS___E2A_L = 0x6E3 // 1763 + SYS_____TOCCSID_A = 0x6E4 // 1764 + SYS_____TOCSNAME_A = 0x6E5 // 1765 + SYS_____CCSIDTYPE_A = 0x6E6 // 1766 + SYS_____CSNAMETYPE_A = 0x6E7 // 1767 + SYS___CHMOD_A = 0x6E8 // 1768 + SYS___MKDIR_A = 0x6E9 // 1769 + SYS___STAT_A = 0x6EA // 1770 + SYS___STAT_O_A = 0x6EB // 1771 + SYS___MKFIFO_A = 0x6EC // 1772 + SYS_____OPEN_STAT_A = 0x6ED // 1773 + SYS___LSTAT_A = 0x6EE // 1774 + SYS___LSTAT_O_A = 0x6EF // 1775 + SYS___MKNOD_A = 0x6F0 // 1776 + SYS___MOUNT_A = 0x6F1 // 1777 + SYS___UMOUNT_A = 0x6F2 // 1778 + SYS___CHAUDIT_A = 0x6F4 // 1780 + SYS___W_GETMNTENT_A = 0x6F5 // 1781 + SYS___CREAT_A = 0x6F6 // 1782 + SYS___OPEN_A = 0x6F7 // 1783 + SYS___SETLOCALE_A = 0x6F9 // 1785 + SYS___FPRINTF_A = 0x6FA // 1786 + SYS___SPRINTF_A = 0x6FB // 1787 + SYS___VFPRINTF_A = 0x6FC // 1788 + SYS___VPRINTF_A = 0x6FD // 1789 + SYS___VSPRINTF_A = 0x6FE // 1790 + SYS___VSWPRINTF_A = 0x6FF // 1791 + SYS___SWPRINTF_A = 0x700 // 1792 + SYS___FSCANF_A = 0x701 // 1793 + SYS___SCANF_A = 0x702 // 1794 + SYS___SSCANF_A = 0x703 // 1795 + SYS___SWSCANF_A = 0x704 // 1796 + SYS___ATOF_A = 0x705 // 1797 + SYS___ATOI_A = 0x706 // 1798 + SYS___ATOL_A = 0x707 // 1799 + SYS___STRTOD_A = 0x708 // 1800 + SYS___STRTOL_A = 0x709 // 1801 + SYS___STRTOUL_A = 0x70A // 1802 + SYS_____AE_CORRESTBL_QUERY_A = 0x70B // 1803 + SYS___A64L_A = 0x70C // 1804 + SYS___ECVT_A = 0x70D // 1805 + SYS___FCVT_A = 0x70E // 1806 + SYS___GCVT_A = 0x70F // 1807 + SYS___L64A_A = 0x710 // 1808 + SYS___STRERROR_A = 0x711 // 1809 + SYS___PERROR_A = 0x712 // 1810 + SYS___FETCH_A = 0x713 // 1811 + SYS___GETENV_A = 0x714 // 1812 + SYS___MKSTEMP_A = 0x717 // 1815 + SYS___PTSNAME_A = 0x718 // 1816 + SYS___PUTENV_A = 0x719 // 1817 + SYS___REALPATH_A = 0x71A // 1818 + SYS___SETENV_A = 0x71B // 1819 + SYS___SYSTEM_A = 0x71C // 1820 + SYS___GETOPT_A = 0x71D // 1821 + SYS___CATOPEN_A = 0x71E // 1822 + SYS___ACCESS_A = 0x71F // 1823 + SYS___CHDIR_A = 0x720 // 1824 + SYS___CHOWN_A = 0x721 // 1825 + SYS___CHROOT_A = 0x722 // 1826 + SYS___GETCWD_A = 0x723 // 1827 + SYS___GETWD_A = 0x724 // 1828 + SYS___LCHOWN_A = 0x725 // 1829 + SYS___LINK_A = 0x726 // 1830 + SYS___PATHCONF_A = 0x727 // 1831 + SYS___IF_NAMEINDEX_A = 0x728 // 1832 + SYS___READLINK_A = 0x729 // 1833 + SYS___RMDIR_A = 0x72A // 1834 + SYS___STATVFS_A = 0x72B // 1835 + SYS___SYMLINK_A = 0x72C // 1836 + SYS___TRUNCATE_A = 0x72D // 1837 + SYS___UNLINK_A = 0x72E // 1838 + SYS___GAI_STRERROR_A = 0x72F // 1839 + SYS___EXTLINK_NP_A = 0x730 // 1840 + SYS___ISALNUM_A = 0x731 // 1841 + SYS___ISALPHA_A = 0x732 // 1842 + SYS___A2E_S = 0x733 // 1843 + SYS___ISCNTRL_A = 0x734 // 1844 + SYS___ISDIGIT_A = 0x735 // 1845 + SYS___ISGRAPH_A = 0x736 // 1846 + SYS___ISLOWER_A = 0x737 // 1847 + SYS___ISPRINT_A = 0x738 // 1848 + SYS___ISPUNCT_A = 0x739 // 1849 + SYS___ISSPACE_A = 0x73A // 1850 + SYS___ISUPPER_A = 0x73B // 1851 + SYS___ISXDIGIT_A = 0x73C // 1852 + SYS___TOLOWER_A = 0x73D // 1853 + SYS___TOUPPER_A = 0x73E // 1854 + SYS___ISWALNUM_A = 0x73F // 1855 + SYS___ISWALPHA_A = 0x740 // 1856 + SYS___A2E_L = 0x741 // 1857 + SYS___ISWCNTRL_A = 0x742 // 1858 + SYS___ISWDIGIT_A = 0x743 // 1859 + SYS___ISWGRAPH_A = 0x744 // 1860 + SYS___ISWLOWER_A = 0x745 // 1861 + SYS___ISWPRINT_A = 0x746 // 1862 + SYS___ISWPUNCT_A = 0x747 // 1863 + SYS___ISWSPACE_A = 0x748 // 1864 + SYS___ISWUPPER_A = 0x749 // 1865 + SYS___ISWXDIGIT_A = 0x74A // 1866 + SYS___CONFSTR_A = 0x74B // 1867 + SYS___FTOK_A = 0x74C // 1868 + SYS___MKTEMP_A = 0x74D // 1869 + SYS___FDOPEN_A = 0x74E // 1870 + SYS___FLDATA_A = 0x74F // 1871 + SYS___REMOVE_A = 0x750 // 1872 + SYS___RENAME_A = 0x751 // 1873 + SYS___TMPNAM_A = 0x752 // 1874 + SYS___FOPEN_A = 0x753 // 1875 + SYS___FREOPEN_A = 0x754 // 1876 + SYS___CUSERID_A = 0x755 // 1877 + SYS___POPEN_A = 0x756 // 1878 + SYS___TEMPNAM_A = 0x757 // 1879 + SYS___FTW_A = 0x758 // 1880 + SYS___GETGRENT_A = 0x759 // 1881 + SYS___GETGRGID_A = 0x75A // 1882 + SYS___GETGRNAM_A = 0x75B // 1883 + SYS___GETGROUPSBYNAME_A = 0x75C // 1884 + SYS___GETHOSTENT_A = 0x75D // 1885 + SYS___GETHOSTNAME_A = 0x75E // 1886 + SYS___GETLOGIN_A = 0x75F // 1887 + SYS___INET_NTOP_A = 0x760 // 1888 + SYS___GETPASS_A = 0x761 // 1889 + SYS___GETPWENT_A = 0x762 // 1890 + SYS___GETPWNAM_A = 0x763 // 1891 + SYS___GETPWUID_A = 0x764 // 1892 + SYS_____CHECK_RESOURCE_AUTH_NP_A = 0x765 // 1893 + SYS___CHECKSCHENV_A = 0x766 // 1894 + SYS___CONNECTSERVER_A = 0x767 // 1895 + SYS___CONNECTWORKMGR_A = 0x768 // 1896 + SYS_____CONSOLE_A = 0x769 // 1897 + SYS___CREATEWORKUNIT_A = 0x76A // 1898 + SYS___CTERMID_A = 0x76B // 1899 + SYS___FMTMSG_A = 0x76C // 1900 + SYS___INITGROUPS_A = 0x76D // 1901 + SYS_____LOGIN_A = 0x76E // 1902 + SYS___MSGRCV_A = 0x76F // 1903 + SYS___MSGSND_A = 0x770 // 1904 + SYS___MSGXRCV_A = 0x771 // 1905 + SYS___NFTW_A = 0x772 // 1906 + SYS_____PASSWD_A = 0x773 // 1907 + SYS___PTHREAD_SECURITY_NP_A = 0x774 // 1908 + SYS___QUERYMETRICS_A = 0x775 // 1909 + SYS___QUERYSCHENV = 0x776 // 1910 + SYS___READV_A = 0x777 // 1911 + SYS_____SERVER_CLASSIFY_A = 0x778 // 1912 + SYS_____SERVER_INIT_A = 0x779 // 1913 + SYS_____SERVER_PWU_A = 0x77A // 1914 + SYS___STRCASECMP_A = 0x77B // 1915 + SYS___STRNCASECMP_A = 0x77C // 1916 + SYS___TTYNAME_A = 0x77D // 1917 + SYS___UNAME_A = 0x77E // 1918 + SYS___UTIMES_A = 0x77F // 1919 + SYS___W_GETPSENT_A = 0x780 // 1920 + SYS___WRITEV_A = 0x781 // 1921 + SYS___W_STATFS_A = 0x782 // 1922 + SYS___W_STATVFS_A = 0x783 // 1923 + SYS___FPUTC_A = 0x784 // 1924 + SYS___PUTCHAR_A = 0x785 // 1925 + SYS___PUTS_A = 0x786 // 1926 + SYS___FGETS_A = 0x787 // 1927 + SYS___GETS_A = 0x788 // 1928 + SYS___FPUTS_A = 0x789 // 1929 + SYS___FREAD_A = 0x78A // 1930 + SYS___FWRITE_A = 0x78B // 1931 + SYS___OPEN_O_A = 0x78C // 1932 + SYS___ISASCII = 0x78D // 1933 + SYS___CREAT_O_A = 0x78E // 1934 + SYS___ENVNA = 0x78F // 1935 + SYS___PUTC_A = 0x790 // 1936 + SYS___AE_THREAD_SETMODE = 0x791 // 1937 + SYS___AE_THREAD_SWAPMODE = 0x792 // 1938 + SYS___GETNETBYADDR_A = 0x793 // 1939 + SYS___GETNETBYNAME_A = 0x794 // 1940 + SYS___GETNETENT_A = 0x795 // 1941 + SYS___GETPROTOBYNAME_A = 0x796 // 1942 + SYS___GETPROTOBYNUMBER_A = 0x797 // 1943 + SYS___GETPROTOENT_A = 0x798 // 1944 + SYS___GETSERVBYNAME_A = 0x799 // 1945 + SYS___GETSERVBYPORT_A = 0x79A // 1946 + SYS___GETSERVENT_A = 0x79B // 1947 + SYS___ASCTIME_A = 0x79C // 1948 + SYS___CTIME_A = 0x79D // 1949 + SYS___GETDATE_A = 0x79E // 1950 + SYS___TZSET_A = 0x79F // 1951 + SYS___UTIME_A = 0x7A0 // 1952 + SYS___ASCTIME_R_A = 0x7A1 // 1953 + SYS___CTIME_R_A = 0x7A2 // 1954 + SYS___STRTOLL_A = 0x7A3 // 1955 + SYS___STRTOULL_A = 0x7A4 // 1956 + SYS___FPUTWC_A = 0x7A5 // 1957 + SYS___PUTWC_A = 0x7A6 // 1958 + SYS___PUTWCHAR_A = 0x7A7 // 1959 + SYS___FPUTWS_A = 0x7A8 // 1960 + SYS___UNGETWC_A = 0x7A9 // 1961 + SYS___FGETWC_A = 0x7AA // 1962 + SYS___GETWC_A = 0x7AB // 1963 + SYS___GETWCHAR_A = 0x7AC // 1964 + SYS___FGETWS_A = 0x7AD // 1965 + SYS___GETTIMEOFDAY_A = 0x7AE // 1966 + SYS___GMTIME_A = 0x7AF // 1967 + SYS___GMTIME_R_A = 0x7B0 // 1968 + SYS___LOCALTIME_A = 0x7B1 // 1969 + SYS___LOCALTIME_R_A = 0x7B2 // 1970 + SYS___MKTIME_A = 0x7B3 // 1971 + SYS___TZZNA = 0x7B4 // 1972 + SYS_UNATEXIT = 0x7B5 // 1973 + SYS___CEE3DMP_A = 0x7B6 // 1974 + SYS___CDUMP_A = 0x7B7 // 1975 + SYS___CSNAP_A = 0x7B8 // 1976 + SYS___CTEST_A = 0x7B9 // 1977 + SYS___CTRACE_A = 0x7BA // 1978 + SYS___VSWPRNTF2_A = 0x7BB // 1979 + SYS___INET_PTON_A = 0x7BC // 1980 + SYS___SYSLOG_A = 0x7BD // 1981 + SYS___CRYPT_A = 0x7BE // 1982 + SYS_____OPENDIR2_A = 0x7BF // 1983 + SYS_____READDIR2_A = 0x7C0 // 1984 + SYS___OPENDIR_A = 0x7C2 // 1986 + SYS___READDIR_A = 0x7C3 // 1987 + SYS_PREAD = 0x7C7 // 1991 + SYS_PWRITE = 0x7C8 // 1992 + SYS_M_CREATE_LAYOUT = 0x7C9 // 1993 + SYS_M_DESTROY_LAYOUT = 0x7CA // 1994 + SYS_M_GETVALUES_LAYOUT = 0x7CB // 1995 + SYS_M_SETVALUES_LAYOUT = 0x7CC // 1996 + SYS_M_TRANSFORM_LAYOUT = 0x7CD // 1997 + SYS_M_WTRANSFORM_LAYOUT = 0x7CE // 1998 + SYS_FWPRINTF = 0x7D1 // 2001 + SYS_WPRINTF = 0x7D2 // 2002 + SYS_VFWPRINT = 0x7D3 // 2003 + SYS_VFWPRINTF = 0x7D3 // 2003 + SYS_VWPRINTF = 0x7D4 // 2004 + SYS_FWSCANF = 0x7D5 // 2005 + SYS_WSCANF = 0x7D6 // 2006 + SYS_WCTRANS = 0x7D7 // 2007 + SYS_TOWCTRAN = 0x7D8 // 2008 + SYS_TOWCTRANS = 0x7D8 // 2008 + SYS___WCSTOD_A = 0x7D9 // 2009 + SYS___WCSTOL_A = 0x7DA // 2010 + SYS___WCSTOUL_A = 0x7DB // 2011 + SYS___BASENAME_A = 0x7DC // 2012 + SYS___DIRNAME_A = 0x7DD // 2013 + SYS___GLOB_A = 0x7DE // 2014 + SYS_FWIDE = 0x7DF // 2015 + SYS___OSNAME = 0x7E0 // 2016 + SYS_____OSNAME_A = 0x7E1 // 2017 + SYS___BTOWC_A = 0x7E4 // 2020 + SYS___WCTOB_A = 0x7E5 // 2021 + SYS___DBM_OPEN_A = 0x7E6 // 2022 + SYS___VFPRINTF2_A = 0x7E7 // 2023 + SYS___VPRINTF2_A = 0x7E8 // 2024 + SYS___VSPRINTF2_A = 0x7E9 // 2025 + SYS___CEIL_H = 0x7EA // 2026 + SYS___FLOOR_H = 0x7EB // 2027 + SYS___MODF_H = 0x7EC // 2028 + SYS___FABS_H = 0x7ED // 2029 + SYS___J0_H = 0x7EE // 2030 + SYS___J1_H = 0x7EF // 2031 + SYS___JN_H = 0x7F0 // 2032 + SYS___Y0_H = 0x7F1 // 2033 + SYS___Y1_H = 0x7F2 // 2034 + SYS___YN_H = 0x7F3 // 2035 + SYS___CEILF_H = 0x7F4 // 2036 + SYS___CEILL_H = 0x7F5 // 2037 + SYS___FLOORF_H = 0x7F6 // 2038 + SYS___FLOORL_H = 0x7F7 // 2039 + SYS___MODFF_H = 0x7F8 // 2040 + SYS___MODFL_H = 0x7F9 // 2041 + SYS___FABSF_H = 0x7FA // 2042 + SYS___FABSL_H = 0x7FB // 2043 + SYS___MALLOC24 = 0x7FC // 2044 + SYS___MALLOC31 = 0x7FD // 2045 + SYS_ACL_INIT = 0x7FE // 2046 + SYS_ACL_FREE = 0x7FF // 2047 + SYS_ACL_FIRST_ENTRY = 0x800 // 2048 + SYS_ACL_GET_ENTRY = 0x801 // 2049 + SYS_ACL_VALID = 0x802 // 2050 + SYS_ACL_CREATE_ENTRY = 0x803 // 2051 + SYS_ACL_DELETE_ENTRY = 0x804 // 2052 + SYS_ACL_UPDATE_ENTRY = 0x805 // 2053 + SYS_ACL_DELETE_FD = 0x806 // 2054 + SYS_ACL_DELETE_FILE = 0x807 // 2055 + SYS_ACL_GET_FD = 0x808 // 2056 + SYS_ACL_GET_FILE = 0x809 // 2057 + SYS_ACL_SET_FD = 0x80A // 2058 + SYS_ACL_SET_FILE = 0x80B // 2059 + SYS_ACL_FROM_TEXT = 0x80C // 2060 + SYS_ACL_TO_TEXT = 0x80D // 2061 + SYS_ACL_SORT = 0x80E // 2062 + SYS___SHUTDOWN_REGISTRATION = 0x80F // 2063 + SYS___ERFL_B = 0x810 // 2064 + SYS___ERFCL_B = 0x811 // 2065 + SYS___LGAMMAL_B = 0x812 // 2066 + SYS___SETHOOKEVENTS = 0x813 // 2067 + SYS_IF_NAMETOINDEX = 0x814 // 2068 + SYS_IF_INDEXTONAME = 0x815 // 2069 + SYS_IF_NAMEINDEX = 0x816 // 2070 + SYS_IF_FREENAMEINDEX = 0x817 // 2071 + SYS_GETADDRINFO = 0x818 // 2072 + SYS_GETNAMEINFO = 0x819 // 2073 + SYS_FREEADDRINFO = 0x81A // 2074 + SYS_GAI_STRERROR = 0x81B // 2075 + SYS_REXEC_AF = 0x81C // 2076 + SYS___POE = 0x81D // 2077 + SYS___DYNALLOC_A = 0x81F // 2079 + SYS___DYNFREE_A = 0x820 // 2080 + SYS___RES_QUERY_A = 0x821 // 2081 + SYS___RES_SEARCH_A = 0x822 // 2082 + SYS___RES_QUERYDOMAIN_A = 0x823 // 2083 + SYS___RES_MKQUERY_A = 0x824 // 2084 + SYS___RES_SEND_A = 0x825 // 2085 + SYS___DN_EXPAND_A = 0x826 // 2086 + SYS___DN_SKIPNAME_A = 0x827 // 2087 + SYS___DN_COMP_A = 0x828 // 2088 + SYS___DN_FIND_A = 0x829 // 2089 + SYS___NLIST_A = 0x82A // 2090 + SYS_____TCGETCP_A = 0x82B // 2091 + SYS_____TCSETCP_A = 0x82C // 2092 + SYS_____W_PIOCTL_A = 0x82E // 2094 + SYS___INET_ADDR_A = 0x82F // 2095 + SYS___INET_NTOA_A = 0x830 // 2096 + SYS___INET_NETWORK_A = 0x831 // 2097 + SYS___ACCEPT_A = 0x832 // 2098 + SYS___ACCEPT_AND_RECV_A = 0x833 // 2099 + SYS___BIND_A = 0x834 // 2100 + SYS___CONNECT_A = 0x835 // 2101 + SYS___GETPEERNAME_A = 0x836 // 2102 + SYS___GETSOCKNAME_A = 0x837 // 2103 + SYS___RECVFROM_A = 0x838 // 2104 + SYS___SENDTO_A = 0x839 // 2105 + SYS___SENDMSG_A = 0x83A // 2106 + SYS___RECVMSG_A = 0x83B // 2107 + SYS_____LCHATTR_A = 0x83C // 2108 + SYS___CABEND = 0x83D // 2109 + SYS___LE_CIB_GET = 0x83E // 2110 + SYS___SET_LAA_FOR_JIT = 0x83F // 2111 + SYS___LCHATTR = 0x840 // 2112 + SYS___WRITEDOWN = 0x841 // 2113 + SYS_PTHREAD_MUTEX_INIT2 = 0x842 // 2114 + SYS___ACOSHF_B = 0x843 // 2115 + SYS___ACOSHL_B = 0x844 // 2116 + SYS___ASINHF_B = 0x845 // 2117 + SYS___ASINHL_B = 0x846 // 2118 + SYS___ATANHF_B = 0x847 // 2119 + SYS___ATANHL_B = 0x848 // 2120 + SYS___CBRTF_B = 0x849 // 2121 + SYS___CBRTL_B = 0x84A // 2122 + SYS___COPYSIGNF_B = 0x84B // 2123 + SYS___COPYSIGNL_B = 0x84C // 2124 + SYS___COTANF_B = 0x84D // 2125 + SYS___COTAN_B = 0x84E // 2126 + SYS___COTANL_B = 0x84F // 2127 + SYS___EXP2F_B = 0x850 // 2128 + SYS___EXP2L_B = 0x851 // 2129 + SYS___EXPM1F_B = 0x852 // 2130 + SYS___EXPM1L_B = 0x853 // 2131 + SYS___FDIMF_B = 0x854 // 2132 + SYS___FDIM_B = 0x855 // 2133 + SYS___FDIML_B = 0x856 // 2134 + SYS___HYPOTF_B = 0x857 // 2135 + SYS___HYPOTL_B = 0x858 // 2136 + SYS___LOG1PF_B = 0x859 // 2137 + SYS___LOG1PL_B = 0x85A // 2138 + SYS___LOG2F_B = 0x85B // 2139 + SYS___LOG2_B = 0x85C // 2140 + SYS___LOG2L_B = 0x85D // 2141 + SYS___REMAINDERF_B = 0x85E // 2142 + SYS___REMAINDERL_B = 0x85F // 2143 + SYS___REMQUOF_B = 0x860 // 2144 + SYS___REMQUO_B = 0x861 // 2145 + SYS___REMQUOL_B = 0x862 // 2146 + SYS___TGAMMAF_B = 0x863 // 2147 + SYS___TGAMMA_B = 0x864 // 2148 + SYS___TGAMMAL_B = 0x865 // 2149 + SYS___TRUNCF_B = 0x866 // 2150 + SYS___TRUNC_B = 0x867 // 2151 + SYS___TRUNCL_B = 0x868 // 2152 + SYS___LGAMMAF_B = 0x869 // 2153 + SYS___LROUNDF_B = 0x86A // 2154 + SYS___LROUND_B = 0x86B // 2155 + SYS___ERFF_B = 0x86C // 2156 + SYS___ERFCF_B = 0x86D // 2157 + SYS_ACOSHF = 0x86E // 2158 + SYS_ACOSHL = 0x86F // 2159 + SYS_ASINHF = 0x870 // 2160 + SYS_ASINHL = 0x871 // 2161 + SYS_ATANHF = 0x872 // 2162 + SYS_ATANHL = 0x873 // 2163 + SYS_CBRTF = 0x874 // 2164 + SYS_CBRTL = 0x875 // 2165 + SYS_COPYSIGNF = 0x876 // 2166 + SYS_CPYSIGNF = 0x876 // 2166 + SYS_COPYSIGNL = 0x877 // 2167 + SYS_CPYSIGNL = 0x877 // 2167 + SYS_COTANF = 0x878 // 2168 + SYS___COTANF = 0x878 // 2168 + SYS_COTAN = 0x879 // 2169 + SYS___COTAN = 0x879 // 2169 + SYS_COTANL = 0x87A // 2170 + SYS___COTANL = 0x87A // 2170 + SYS_EXP2F = 0x87B // 2171 + SYS_EXP2L = 0x87C // 2172 + SYS_EXPM1F = 0x87D // 2173 + SYS_EXPM1L = 0x87E // 2174 + SYS_FDIMF = 0x87F // 2175 + SYS_FDIM = 0x881 // 2177 + SYS_FDIML = 0x882 // 2178 + SYS_HYPOTF = 0x883 // 2179 + SYS_HYPOTL = 0x884 // 2180 + SYS_LOG1PF = 0x885 // 2181 + SYS_LOG1PL = 0x886 // 2182 + SYS_LOG2F = 0x887 // 2183 + SYS_LOG2 = 0x888 // 2184 + SYS_LOG2L = 0x889 // 2185 + SYS_REMAINDERF = 0x88A // 2186 + SYS_REMAINDF = 0x88A // 2186 + SYS_REMAINDERL = 0x88B // 2187 + SYS_REMAINDL = 0x88B // 2187 + SYS_REMQUOF = 0x88C // 2188 + SYS_REMQUO = 0x88D // 2189 + SYS_REMQUOL = 0x88E // 2190 + SYS_TGAMMAF = 0x88F // 2191 + SYS_TGAMMA = 0x890 // 2192 + SYS_TGAMMAL = 0x891 // 2193 + SYS_TRUNCF = 0x892 // 2194 + SYS_TRUNC = 0x893 // 2195 + SYS_TRUNCL = 0x894 // 2196 + SYS_LGAMMAF = 0x895 // 2197 + SYS_LGAMMAL = 0x896 // 2198 + SYS_LROUNDF = 0x897 // 2199 + SYS_LROUND = 0x898 // 2200 + SYS_ERFF = 0x899 // 2201 + SYS_ERFL = 0x89A // 2202 + SYS_ERFCF = 0x89B // 2203 + SYS_ERFCL = 0x89C // 2204 + SYS___EXP2_B = 0x89D // 2205 + SYS_EXP2 = 0x89E // 2206 + SYS___FAR_JUMP = 0x89F // 2207 + SYS___TCGETATTR_A = 0x8A1 // 2209 + SYS___TCSETATTR_A = 0x8A2 // 2210 + SYS___SUPERKILL = 0x8A4 // 2212 + SYS___LE_CONDITION_TOKEN_BUILD = 0x8A5 // 2213 + SYS___LE_MSG_ADD_INSERT = 0x8A6 // 2214 + SYS___LE_MSG_GET = 0x8A7 // 2215 + SYS___LE_MSG_GET_AND_WRITE = 0x8A8 // 2216 + SYS___LE_MSG_WRITE = 0x8A9 // 2217 + SYS___ITOA = 0x8AA // 2218 + SYS___UTOA = 0x8AB // 2219 + SYS___LTOA = 0x8AC // 2220 + SYS___ULTOA = 0x8AD // 2221 + SYS___LLTOA = 0x8AE // 2222 + SYS___ULLTOA = 0x8AF // 2223 + SYS___ITOA_A = 0x8B0 // 2224 + SYS___UTOA_A = 0x8B1 // 2225 + SYS___LTOA_A = 0x8B2 // 2226 + SYS___ULTOA_A = 0x8B3 // 2227 + SYS___LLTOA_A = 0x8B4 // 2228 + SYS___ULLTOA_A = 0x8B5 // 2229 + SYS_____GETENV_A = 0x8C3 // 2243 + SYS___REXEC_A = 0x8C4 // 2244 + SYS___REXEC_AF_A = 0x8C5 // 2245 + SYS___GETUTXENT_A = 0x8C6 // 2246 + SYS___GETUTXID_A = 0x8C7 // 2247 + SYS___GETUTXLINE_A = 0x8C8 // 2248 + SYS___PUTUTXLINE_A = 0x8C9 // 2249 + SYS_____UTMPXNAME_A = 0x8CA // 2250 + SYS___PUTC_UNLOCKED_A = 0x8CB // 2251 + SYS___PUTCHAR_UNLOCKED_A = 0x8CC // 2252 + SYS___SNPRINTF_A = 0x8CD // 2253 + SYS___VSNPRINTF_A = 0x8CE // 2254 + SYS___DLOPEN_A = 0x8D0 // 2256 + SYS___DLSYM_A = 0x8D1 // 2257 + SYS___DLERROR_A = 0x8D2 // 2258 + SYS_FLOCKFILE = 0x8D3 // 2259 + SYS_FTRYLOCKFILE = 0x8D4 // 2260 + SYS_FUNLOCKFILE = 0x8D5 // 2261 + SYS_GETC_UNLOCKED = 0x8D6 // 2262 + SYS_GETCHAR_UNLOCKED = 0x8D7 // 2263 + SYS_PUTC_UNLOCKED = 0x8D8 // 2264 + SYS_PUTCHAR_UNLOCKED = 0x8D9 // 2265 + SYS_SNPRINTF = 0x8DA // 2266 + SYS_VSNPRINTF = 0x8DB // 2267 + SYS_DLOPEN = 0x8DD // 2269 + SYS_DLSYM = 0x8DE // 2270 + SYS_DLCLOSE = 0x8DF // 2271 + SYS_DLERROR = 0x8E0 // 2272 + SYS___SET_EXCEPTION_HANDLER = 0x8E2 // 2274 + SYS___RESET_EXCEPTION_HANDLER = 0x8E3 // 2275 + SYS___VHM_EVENT = 0x8E4 // 2276 + SYS___ABS_H = 0x8E6 // 2278 + SYS___ABSF_H = 0x8E7 // 2279 + SYS___ABSL_H = 0x8E8 // 2280 + SYS___ACOS_H = 0x8E9 // 2281 + SYS___ACOSF_H = 0x8EA // 2282 + SYS___ACOSL_H = 0x8EB // 2283 + SYS___ACOSH_H = 0x8EC // 2284 + SYS___ASIN_H = 0x8ED // 2285 + SYS___ASINF_H = 0x8EE // 2286 + SYS___ASINL_H = 0x8EF // 2287 + SYS___ASINH_H = 0x8F0 // 2288 + SYS___ATAN_H = 0x8F1 // 2289 + SYS___ATANF_H = 0x8F2 // 2290 + SYS___ATANL_H = 0x8F3 // 2291 + SYS___ATANH_H = 0x8F4 // 2292 + SYS___ATANHF_H = 0x8F5 // 2293 + SYS___ATANHL_H = 0x8F6 // 2294 + SYS___ATAN2_H = 0x8F7 // 2295 + SYS___ATAN2F_H = 0x8F8 // 2296 + SYS___ATAN2L_H = 0x8F9 // 2297 + SYS___CBRT_H = 0x8FA // 2298 + SYS___COPYSIGNF_H = 0x8FB // 2299 + SYS___COPYSIGNL_H = 0x8FC // 2300 + SYS___COS_H = 0x8FD // 2301 + SYS___COSF_H = 0x8FE // 2302 + SYS___COSL_H = 0x8FF // 2303 + SYS___COSHF_H = 0x900 // 2304 + SYS___COSHL_H = 0x901 // 2305 + SYS___COTAN_H = 0x902 // 2306 + SYS___COTANF_H = 0x903 // 2307 + SYS___COTANL_H = 0x904 // 2308 + SYS___ERF_H = 0x905 // 2309 + SYS___ERFF_H = 0x906 // 2310 + SYS___ERFL_H = 0x907 // 2311 + SYS___ERFC_H = 0x908 // 2312 + SYS___ERFCF_H = 0x909 // 2313 + SYS___ERFCL_H = 0x90A // 2314 + SYS___EXP_H = 0x90B // 2315 + SYS___EXPF_H = 0x90C // 2316 + SYS___EXPL_H = 0x90D // 2317 + SYS___EXPM1_H = 0x90E // 2318 + SYS___FDIM_H = 0x90F // 2319 + SYS___FDIMF_H = 0x910 // 2320 + SYS___FDIML_H = 0x911 // 2321 + SYS___FMOD_H = 0x912 // 2322 + SYS___FMODF_H = 0x913 // 2323 + SYS___FMODL_H = 0x914 // 2324 + SYS___GAMMA_H = 0x915 // 2325 + SYS___HYPOT_H = 0x916 // 2326 + SYS___ILOGB_H = 0x917 // 2327 + SYS___LGAMMA_H = 0x918 // 2328 + SYS___LGAMMAF_H = 0x919 // 2329 + SYS___LOG_H = 0x91A // 2330 + SYS___LOGF_H = 0x91B // 2331 + SYS___LOGL_H = 0x91C // 2332 + SYS___LOGB_H = 0x91D // 2333 + SYS___LOG2_H = 0x91E // 2334 + SYS___LOG2F_H = 0x91F // 2335 + SYS___LOG2L_H = 0x920 // 2336 + SYS___LOG1P_H = 0x921 // 2337 + SYS___LOG10_H = 0x922 // 2338 + SYS___LOG10F_H = 0x923 // 2339 + SYS___LOG10L_H = 0x924 // 2340 + SYS___LROUND_H = 0x925 // 2341 + SYS___LROUNDF_H = 0x926 // 2342 + SYS___NEXTAFTER_H = 0x927 // 2343 + SYS___POW_H = 0x928 // 2344 + SYS___POWF_H = 0x929 // 2345 + SYS___POWL_H = 0x92A // 2346 + SYS___REMAINDER_H = 0x92B // 2347 + SYS___RINT_H = 0x92C // 2348 + SYS___SCALB_H = 0x92D // 2349 + SYS___SIN_H = 0x92E // 2350 + SYS___SINF_H = 0x92F // 2351 + SYS___SINL_H = 0x930 // 2352 + SYS___SINH_H = 0x931 // 2353 + SYS___SINHF_H = 0x932 // 2354 + SYS___SINHL_H = 0x933 // 2355 + SYS___SQRT_H = 0x934 // 2356 + SYS___SQRTF_H = 0x935 // 2357 + SYS___SQRTL_H = 0x936 // 2358 + SYS___TAN_H = 0x937 // 2359 + SYS___TANF_H = 0x938 // 2360 + SYS___TANL_H = 0x939 // 2361 + SYS___TANH_H = 0x93A // 2362 + SYS___TANHF_H = 0x93B // 2363 + SYS___TANHL_H = 0x93C // 2364 + SYS___TGAMMA_H = 0x93D // 2365 + SYS___TGAMMAF_H = 0x93E // 2366 + SYS___TRUNC_H = 0x93F // 2367 + SYS___TRUNCF_H = 0x940 // 2368 + SYS___TRUNCL_H = 0x941 // 2369 + SYS___COSH_H = 0x942 // 2370 + SYS___LE_DEBUG_SET_RESUME_MCH = 0x943 // 2371 + SYS_VFSCANF = 0x944 // 2372 + SYS_VSCANF = 0x946 // 2374 + SYS_VSSCANF = 0x948 // 2376 + SYS_VFWSCANF = 0x94A // 2378 + SYS_VWSCANF = 0x94C // 2380 + SYS_VSWSCANF = 0x94E // 2382 + SYS_IMAXABS = 0x950 // 2384 + SYS_IMAXDIV = 0x951 // 2385 + SYS_STRTOIMAX = 0x952 // 2386 + SYS_STRTOUMAX = 0x953 // 2387 + SYS_WCSTOIMAX = 0x954 // 2388 + SYS_WCSTOUMAX = 0x955 // 2389 + SYS_ATOLL = 0x956 // 2390 + SYS_STRTOF = 0x957 // 2391 + SYS_STRTOLD = 0x958 // 2392 + SYS_WCSTOF = 0x959 // 2393 + SYS_WCSTOLD = 0x95A // 2394 + SYS_INET6_RTH_SPACE = 0x95B // 2395 + SYS_INET6_RTH_INIT = 0x95C // 2396 + SYS_INET6_RTH_ADD = 0x95D // 2397 + SYS_INET6_RTH_REVERSE = 0x95E // 2398 + SYS_INET6_RTH_SEGMENTS = 0x95F // 2399 + SYS_INET6_RTH_GETADDR = 0x960 // 2400 + SYS_INET6_OPT_INIT = 0x961 // 2401 + SYS_INET6_OPT_APPEND = 0x962 // 2402 + SYS_INET6_OPT_FINISH = 0x963 // 2403 + SYS_INET6_OPT_SET_VAL = 0x964 // 2404 + SYS_INET6_OPT_NEXT = 0x965 // 2405 + SYS_INET6_OPT_FIND = 0x966 // 2406 + SYS_INET6_OPT_GET_VAL = 0x967 // 2407 + SYS___POW_I = 0x987 // 2439 + SYS___POW_I_B = 0x988 // 2440 + SYS___POW_I_H = 0x989 // 2441 + SYS___POW_II = 0x98A // 2442 + SYS___POW_II_B = 0x98B // 2443 + SYS___POW_II_H = 0x98C // 2444 + SYS_CABS = 0x98E // 2446 + SYS___CABS_B = 0x98F // 2447 + SYS___CABS_H = 0x990 // 2448 + SYS_CABSF = 0x991 // 2449 + SYS___CABSF_B = 0x992 // 2450 + SYS___CABSF_H = 0x993 // 2451 + SYS_CABSL = 0x994 // 2452 + SYS___CABSL_B = 0x995 // 2453 + SYS___CABSL_H = 0x996 // 2454 + SYS_CACOS = 0x997 // 2455 + SYS___CACOS_B = 0x998 // 2456 + SYS___CACOS_H = 0x999 // 2457 + SYS_CACOSF = 0x99A // 2458 + SYS___CACOSF_B = 0x99B // 2459 + SYS___CACOSF_H = 0x99C // 2460 + SYS_CACOSL = 0x99D // 2461 + SYS___CACOSL_B = 0x99E // 2462 + SYS___CACOSL_H = 0x99F // 2463 + SYS_CACOSH = 0x9A0 // 2464 + SYS___CACOSH_B = 0x9A1 // 2465 + SYS___CACOSH_H = 0x9A2 // 2466 + SYS_CACOSHF = 0x9A3 // 2467 + SYS___CACOSHF_B = 0x9A4 // 2468 + SYS___CACOSHF_H = 0x9A5 // 2469 + SYS_CACOSHL = 0x9A6 // 2470 + SYS___CACOSHL_B = 0x9A7 // 2471 + SYS___CACOSHL_H = 0x9A8 // 2472 + SYS_CARG = 0x9A9 // 2473 + SYS___CARG_B = 0x9AA // 2474 + SYS___CARG_H = 0x9AB // 2475 + SYS_CARGF = 0x9AC // 2476 + SYS___CARGF_B = 0x9AD // 2477 + SYS___CARGF_H = 0x9AE // 2478 + SYS_CARGL = 0x9AF // 2479 + SYS___CARGL_B = 0x9B0 // 2480 + SYS___CARGL_H = 0x9B1 // 2481 + SYS_CASIN = 0x9B2 // 2482 + SYS___CASIN_B = 0x9B3 // 2483 + SYS___CASIN_H = 0x9B4 // 2484 + SYS_CASINF = 0x9B5 // 2485 + SYS___CASINF_B = 0x9B6 // 2486 + SYS___CASINF_H = 0x9B7 // 2487 + SYS_CASINL = 0x9B8 // 2488 + SYS___CASINL_B = 0x9B9 // 2489 + SYS___CASINL_H = 0x9BA // 2490 + SYS_CASINH = 0x9BB // 2491 + SYS___CASINH_B = 0x9BC // 2492 + SYS___CASINH_H = 0x9BD // 2493 + SYS_CASINHF = 0x9BE // 2494 + SYS___CASINHF_B = 0x9BF // 2495 + SYS___CASINHF_H = 0x9C0 // 2496 + SYS_CASINHL = 0x9C1 // 2497 + SYS___CASINHL_B = 0x9C2 // 2498 + SYS___CASINHL_H = 0x9C3 // 2499 + SYS_CATAN = 0x9C4 // 2500 + SYS___CATAN_B = 0x9C5 // 2501 + SYS___CATAN_H = 0x9C6 // 2502 + SYS_CATANF = 0x9C7 // 2503 + SYS___CATANF_B = 0x9C8 // 2504 + SYS___CATANF_H = 0x9C9 // 2505 + SYS_CATANL = 0x9CA // 2506 + SYS___CATANL_B = 0x9CB // 2507 + SYS___CATANL_H = 0x9CC // 2508 + SYS_CATANH = 0x9CD // 2509 + SYS___CATANH_B = 0x9CE // 2510 + SYS___CATANH_H = 0x9CF // 2511 + SYS_CATANHF = 0x9D0 // 2512 + SYS___CATANHF_B = 0x9D1 // 2513 + SYS___CATANHF_H = 0x9D2 // 2514 + SYS_CATANHL = 0x9D3 // 2515 + SYS___CATANHL_B = 0x9D4 // 2516 + SYS___CATANHL_H = 0x9D5 // 2517 + SYS_CCOS = 0x9D6 // 2518 + SYS___CCOS_B = 0x9D7 // 2519 + SYS___CCOS_H = 0x9D8 // 2520 + SYS_CCOSF = 0x9D9 // 2521 + SYS___CCOSF_B = 0x9DA // 2522 + SYS___CCOSF_H = 0x9DB // 2523 + SYS_CCOSL = 0x9DC // 2524 + SYS___CCOSL_B = 0x9DD // 2525 + SYS___CCOSL_H = 0x9DE // 2526 + SYS_CCOSH = 0x9DF // 2527 + SYS___CCOSH_B = 0x9E0 // 2528 + SYS___CCOSH_H = 0x9E1 // 2529 + SYS_CCOSHF = 0x9E2 // 2530 + SYS___CCOSHF_B = 0x9E3 // 2531 + SYS___CCOSHF_H = 0x9E4 // 2532 + SYS_CCOSHL = 0x9E5 // 2533 + SYS___CCOSHL_B = 0x9E6 // 2534 + SYS___CCOSHL_H = 0x9E7 // 2535 + SYS_CEXP = 0x9E8 // 2536 + SYS___CEXP_B = 0x9E9 // 2537 + SYS___CEXP_H = 0x9EA // 2538 + SYS_CEXPF = 0x9EB // 2539 + SYS___CEXPF_B = 0x9EC // 2540 + SYS___CEXPF_H = 0x9ED // 2541 + SYS_CEXPL = 0x9EE // 2542 + SYS___CEXPL_B = 0x9EF // 2543 + SYS___CEXPL_H = 0x9F0 // 2544 + SYS_CIMAG = 0x9F1 // 2545 + SYS___CIMAG_B = 0x9F2 // 2546 + SYS___CIMAG_H = 0x9F3 // 2547 + SYS_CIMAGF = 0x9F4 // 2548 + SYS___CIMAGF_B = 0x9F5 // 2549 + SYS___CIMAGF_H = 0x9F6 // 2550 + SYS_CIMAGL = 0x9F7 // 2551 + SYS___CIMAGL_B = 0x9F8 // 2552 + SYS___CIMAGL_H = 0x9F9 // 2553 + SYS___CLOG = 0x9FA // 2554 + SYS___CLOG_B = 0x9FB // 2555 + SYS___CLOG_H = 0x9FC // 2556 + SYS_CLOGF = 0x9FD // 2557 + SYS___CLOGF_B = 0x9FE // 2558 + SYS___CLOGF_H = 0x9FF // 2559 + SYS_CLOGL = 0xA00 // 2560 + SYS___CLOGL_B = 0xA01 // 2561 + SYS___CLOGL_H = 0xA02 // 2562 + SYS_CONJ = 0xA03 // 2563 + SYS___CONJ_B = 0xA04 // 2564 + SYS___CONJ_H = 0xA05 // 2565 + SYS_CONJF = 0xA06 // 2566 + SYS___CONJF_B = 0xA07 // 2567 + SYS___CONJF_H = 0xA08 // 2568 + SYS_CONJL = 0xA09 // 2569 + SYS___CONJL_B = 0xA0A // 2570 + SYS___CONJL_H = 0xA0B // 2571 + SYS_CPOW = 0xA0C // 2572 + SYS___CPOW_B = 0xA0D // 2573 + SYS___CPOW_H = 0xA0E // 2574 + SYS_CPOWF = 0xA0F // 2575 + SYS___CPOWF_B = 0xA10 // 2576 + SYS___CPOWF_H = 0xA11 // 2577 + SYS_CPOWL = 0xA12 // 2578 + SYS___CPOWL_B = 0xA13 // 2579 + SYS___CPOWL_H = 0xA14 // 2580 + SYS_CPROJ = 0xA15 // 2581 + SYS___CPROJ_B = 0xA16 // 2582 + SYS___CPROJ_H = 0xA17 // 2583 + SYS_CPROJF = 0xA18 // 2584 + SYS___CPROJF_B = 0xA19 // 2585 + SYS___CPROJF_H = 0xA1A // 2586 + SYS_CPROJL = 0xA1B // 2587 + SYS___CPROJL_B = 0xA1C // 2588 + SYS___CPROJL_H = 0xA1D // 2589 + SYS_CREAL = 0xA1E // 2590 + SYS___CREAL_B = 0xA1F // 2591 + SYS___CREAL_H = 0xA20 // 2592 + SYS_CREALF = 0xA21 // 2593 + SYS___CREALF_B = 0xA22 // 2594 + SYS___CREALF_H = 0xA23 // 2595 + SYS_CREALL = 0xA24 // 2596 + SYS___CREALL_B = 0xA25 // 2597 + SYS___CREALL_H = 0xA26 // 2598 + SYS_CSIN = 0xA27 // 2599 + SYS___CSIN_B = 0xA28 // 2600 + SYS___CSIN_H = 0xA29 // 2601 + SYS_CSINF = 0xA2A // 2602 + SYS___CSINF_B = 0xA2B // 2603 + SYS___CSINF_H = 0xA2C // 2604 + SYS_CSINL = 0xA2D // 2605 + SYS___CSINL_B = 0xA2E // 2606 + SYS___CSINL_H = 0xA2F // 2607 + SYS_CSINH = 0xA30 // 2608 + SYS___CSINH_B = 0xA31 // 2609 + SYS___CSINH_H = 0xA32 // 2610 + SYS_CSINHF = 0xA33 // 2611 + SYS___CSINHF_B = 0xA34 // 2612 + SYS___CSINHF_H = 0xA35 // 2613 + SYS_CSINHL = 0xA36 // 2614 + SYS___CSINHL_B = 0xA37 // 2615 + SYS___CSINHL_H = 0xA38 // 2616 + SYS_CSQRT = 0xA39 // 2617 + SYS___CSQRT_B = 0xA3A // 2618 + SYS___CSQRT_H = 0xA3B // 2619 + SYS_CSQRTF = 0xA3C // 2620 + SYS___CSQRTF_B = 0xA3D // 2621 + SYS___CSQRTF_H = 0xA3E // 2622 + SYS_CSQRTL = 0xA3F // 2623 + SYS___CSQRTL_B = 0xA40 // 2624 + SYS___CSQRTL_H = 0xA41 // 2625 + SYS_CTAN = 0xA42 // 2626 + SYS___CTAN_B = 0xA43 // 2627 + SYS___CTAN_H = 0xA44 // 2628 + SYS_CTANF = 0xA45 // 2629 + SYS___CTANF_B = 0xA46 // 2630 + SYS___CTANF_H = 0xA47 // 2631 + SYS_CTANL = 0xA48 // 2632 + SYS___CTANL_B = 0xA49 // 2633 + SYS___CTANL_H = 0xA4A // 2634 + SYS_CTANH = 0xA4B // 2635 + SYS___CTANH_B = 0xA4C // 2636 + SYS___CTANH_H = 0xA4D // 2637 + SYS_CTANHF = 0xA4E // 2638 + SYS___CTANHF_B = 0xA4F // 2639 + SYS___CTANHF_H = 0xA50 // 2640 + SYS_CTANHL = 0xA51 // 2641 + SYS___CTANHL_B = 0xA52 // 2642 + SYS___CTANHL_H = 0xA53 // 2643 + SYS___ACOSHF_H = 0xA54 // 2644 + SYS___ACOSHL_H = 0xA55 // 2645 + SYS___ASINHF_H = 0xA56 // 2646 + SYS___ASINHL_H = 0xA57 // 2647 + SYS___CBRTF_H = 0xA58 // 2648 + SYS___CBRTL_H = 0xA59 // 2649 + SYS___COPYSIGN_B = 0xA5A // 2650 + SYS___EXPM1F_H = 0xA5B // 2651 + SYS___EXPM1L_H = 0xA5C // 2652 + SYS___EXP2_H = 0xA5D // 2653 + SYS___EXP2F_H = 0xA5E // 2654 + SYS___EXP2L_H = 0xA5F // 2655 + SYS___LOG1PF_H = 0xA60 // 2656 + SYS___LOG1PL_H = 0xA61 // 2657 + SYS___LGAMMAL_H = 0xA62 // 2658 + SYS_FMA = 0xA63 // 2659 + SYS___FMA_B = 0xA64 // 2660 + SYS___FMA_H = 0xA65 // 2661 + SYS_FMAF = 0xA66 // 2662 + SYS___FMAF_B = 0xA67 // 2663 + SYS___FMAF_H = 0xA68 // 2664 + SYS_FMAL = 0xA69 // 2665 + SYS___FMAL_B = 0xA6A // 2666 + SYS___FMAL_H = 0xA6B // 2667 + SYS_FMAX = 0xA6C // 2668 + SYS___FMAX_B = 0xA6D // 2669 + SYS___FMAX_H = 0xA6E // 2670 + SYS_FMAXF = 0xA6F // 2671 + SYS___FMAXF_B = 0xA70 // 2672 + SYS___FMAXF_H = 0xA71 // 2673 + SYS_FMAXL = 0xA72 // 2674 + SYS___FMAXL_B = 0xA73 // 2675 + SYS___FMAXL_H = 0xA74 // 2676 + SYS_FMIN = 0xA75 // 2677 + SYS___FMIN_B = 0xA76 // 2678 + SYS___FMIN_H = 0xA77 // 2679 + SYS_FMINF = 0xA78 // 2680 + SYS___FMINF_B = 0xA79 // 2681 + SYS___FMINF_H = 0xA7A // 2682 + SYS_FMINL = 0xA7B // 2683 + SYS___FMINL_B = 0xA7C // 2684 + SYS___FMINL_H = 0xA7D // 2685 + SYS_ILOGBF = 0xA7E // 2686 + SYS___ILOGBF_B = 0xA7F // 2687 + SYS___ILOGBF_H = 0xA80 // 2688 + SYS_ILOGBL = 0xA81 // 2689 + SYS___ILOGBL_B = 0xA82 // 2690 + SYS___ILOGBL_H = 0xA83 // 2691 + SYS_LLRINT = 0xA84 // 2692 + SYS___LLRINT_B = 0xA85 // 2693 + SYS___LLRINT_H = 0xA86 // 2694 + SYS_LLRINTF = 0xA87 // 2695 + SYS___LLRINTF_B = 0xA88 // 2696 + SYS___LLRINTF_H = 0xA89 // 2697 + SYS_LLRINTL = 0xA8A // 2698 + SYS___LLRINTL_B = 0xA8B // 2699 + SYS___LLRINTL_H = 0xA8C // 2700 + SYS_LLROUND = 0xA8D // 2701 + SYS___LLROUND_B = 0xA8E // 2702 + SYS___LLROUND_H = 0xA8F // 2703 + SYS_LLROUNDF = 0xA90 // 2704 + SYS___LLROUNDF_B = 0xA91 // 2705 + SYS___LLROUNDF_H = 0xA92 // 2706 + SYS_LLROUNDL = 0xA93 // 2707 + SYS___LLROUNDL_B = 0xA94 // 2708 + SYS___LLROUNDL_H = 0xA95 // 2709 + SYS_LOGBF = 0xA96 // 2710 + SYS___LOGBF_B = 0xA97 // 2711 + SYS___LOGBF_H = 0xA98 // 2712 + SYS_LOGBL = 0xA99 // 2713 + SYS___LOGBL_B = 0xA9A // 2714 + SYS___LOGBL_H = 0xA9B // 2715 + SYS_LRINT = 0xA9C // 2716 + SYS___LRINT_B = 0xA9D // 2717 + SYS___LRINT_H = 0xA9E // 2718 + SYS_LRINTF = 0xA9F // 2719 + SYS___LRINTF_B = 0xAA0 // 2720 + SYS___LRINTF_H = 0xAA1 // 2721 + SYS_LRINTL = 0xAA2 // 2722 + SYS___LRINTL_B = 0xAA3 // 2723 + SYS___LRINTL_H = 0xAA4 // 2724 + SYS_LROUNDL = 0xAA5 // 2725 + SYS___LROUNDL_B = 0xAA6 // 2726 + SYS___LROUNDL_H = 0xAA7 // 2727 + SYS_NAN = 0xAA8 // 2728 + SYS___NAN_B = 0xAA9 // 2729 + SYS_NANF = 0xAAA // 2730 + SYS___NANF_B = 0xAAB // 2731 + SYS_NANL = 0xAAC // 2732 + SYS___NANL_B = 0xAAD // 2733 + SYS_NEARBYINT = 0xAAE // 2734 + SYS___NEARBYINT_B = 0xAAF // 2735 + SYS___NEARBYINT_H = 0xAB0 // 2736 + SYS_NEARBYINTF = 0xAB1 // 2737 + SYS___NEARBYINTF_B = 0xAB2 // 2738 + SYS___NEARBYINTF_H = 0xAB3 // 2739 + SYS_NEARBYINTL = 0xAB4 // 2740 + SYS___NEARBYINTL_B = 0xAB5 // 2741 + SYS___NEARBYINTL_H = 0xAB6 // 2742 + SYS_NEXTAFTERF = 0xAB7 // 2743 + SYS___NEXTAFTERF_B = 0xAB8 // 2744 + SYS___NEXTAFTERF_H = 0xAB9 // 2745 + SYS_NEXTAFTERL = 0xABA // 2746 + SYS___NEXTAFTERL_B = 0xABB // 2747 + SYS___NEXTAFTERL_H = 0xABC // 2748 + SYS_NEXTTOWARD = 0xABD // 2749 + SYS___NEXTTOWARD_B = 0xABE // 2750 + SYS___NEXTTOWARD_H = 0xABF // 2751 + SYS_NEXTTOWARDF = 0xAC0 // 2752 + SYS___NEXTTOWARDF_B = 0xAC1 // 2753 + SYS___NEXTTOWARDF_H = 0xAC2 // 2754 + SYS_NEXTTOWARDL = 0xAC3 // 2755 + SYS___NEXTTOWARDL_B = 0xAC4 // 2756 + SYS___NEXTTOWARDL_H = 0xAC5 // 2757 + SYS___REMAINDERF_H = 0xAC6 // 2758 + SYS___REMAINDERL_H = 0xAC7 // 2759 + SYS___REMQUO_H = 0xAC8 // 2760 + SYS___REMQUOF_H = 0xAC9 // 2761 + SYS___REMQUOL_H = 0xACA // 2762 + SYS_RINTF = 0xACB // 2763 + SYS___RINTF_B = 0xACC // 2764 + SYS_RINTL = 0xACD // 2765 + SYS___RINTL_B = 0xACE // 2766 + SYS_ROUND = 0xACF // 2767 + SYS___ROUND_B = 0xAD0 // 2768 + SYS___ROUND_H = 0xAD1 // 2769 + SYS_ROUNDF = 0xAD2 // 2770 + SYS___ROUNDF_B = 0xAD3 // 2771 + SYS___ROUNDF_H = 0xAD4 // 2772 + SYS_ROUNDL = 0xAD5 // 2773 + SYS___ROUNDL_B = 0xAD6 // 2774 + SYS___ROUNDL_H = 0xAD7 // 2775 + SYS_SCALBLN = 0xAD8 // 2776 + SYS___SCALBLN_B = 0xAD9 // 2777 + SYS___SCALBLN_H = 0xADA // 2778 + SYS_SCALBLNF = 0xADB // 2779 + SYS___SCALBLNF_B = 0xADC // 2780 + SYS___SCALBLNF_H = 0xADD // 2781 + SYS_SCALBLNL = 0xADE // 2782 + SYS___SCALBLNL_B = 0xADF // 2783 + SYS___SCALBLNL_H = 0xAE0 // 2784 + SYS___SCALBN_B = 0xAE1 // 2785 + SYS___SCALBN_H = 0xAE2 // 2786 + SYS_SCALBNF = 0xAE3 // 2787 + SYS___SCALBNF_B = 0xAE4 // 2788 + SYS___SCALBNF_H = 0xAE5 // 2789 + SYS_SCALBNL = 0xAE6 // 2790 + SYS___SCALBNL_B = 0xAE7 // 2791 + SYS___SCALBNL_H = 0xAE8 // 2792 + SYS___TGAMMAL_H = 0xAE9 // 2793 + SYS_FECLEAREXCEPT = 0xAEA // 2794 + SYS_FEGETENV = 0xAEB // 2795 + SYS_FEGETEXCEPTFLAG = 0xAEC // 2796 + SYS_FEGETROUND = 0xAED // 2797 + SYS_FEHOLDEXCEPT = 0xAEE // 2798 + SYS_FERAISEEXCEPT = 0xAEF // 2799 + SYS_FESETENV = 0xAF0 // 2800 + SYS_FESETEXCEPTFLAG = 0xAF1 // 2801 + SYS_FESETROUND = 0xAF2 // 2802 + SYS_FETESTEXCEPT = 0xAF3 // 2803 + SYS_FEUPDATEENV = 0xAF4 // 2804 + SYS___COPYSIGN_H = 0xAF5 // 2805 + SYS___HYPOTF_H = 0xAF6 // 2806 + SYS___HYPOTL_H = 0xAF7 // 2807 + SYS___CLASS = 0xAFA // 2810 + SYS___CLASS_B = 0xAFB // 2811 + SYS___CLASS_H = 0xAFC // 2812 + SYS___ISBLANK_A = 0xB2E // 2862 + SYS___ISWBLANK_A = 0xB2F // 2863 + SYS___LROUND_FIXUP = 0xB30 // 2864 + SYS___LROUNDF_FIXUP = 0xB31 // 2865 + SYS_SCHED_YIELD = 0xB32 // 2866 + SYS_STRERROR_R = 0xB33 // 2867 + SYS_UNSETENV = 0xB34 // 2868 + SYS___LGAMMA_H_C99 = 0xB38 // 2872 + SYS___LGAMMA_B_C99 = 0xB39 // 2873 + SYS___LGAMMA_R_C99 = 0xB3A // 2874 + SYS___FTELL2 = 0xB3B // 2875 + SYS___FSEEK2 = 0xB3C // 2876 + SYS___STATIC_REINIT = 0xB3D // 2877 + SYS_PTHREAD_ATTR_GETSTACK = 0xB3E // 2878 + SYS_PTHREAD_ATTR_SETSTACK = 0xB3F // 2879 + SYS___TGAMMA_H_C99 = 0xB78 // 2936 + SYS___TGAMMAF_H_C99 = 0xB79 // 2937 + SYS___LE_TRACEBACK = 0xB7A // 2938 + SYS___MUST_STAY_CLEAN = 0xB7C // 2940 + SYS___O_ENV = 0xB7D // 2941 + SYS_ACOSD32 = 0xB7E // 2942 + SYS_ACOSD64 = 0xB7F // 2943 + SYS_ACOSD128 = 0xB80 // 2944 + SYS_ACOSHD32 = 0xB81 // 2945 + SYS_ACOSHD64 = 0xB82 // 2946 + SYS_ACOSHD128 = 0xB83 // 2947 + SYS_ASIND32 = 0xB84 // 2948 + SYS_ASIND64 = 0xB85 // 2949 + SYS_ASIND128 = 0xB86 // 2950 + SYS_ASINHD32 = 0xB87 // 2951 + SYS_ASINHD64 = 0xB88 // 2952 + SYS_ASINHD128 = 0xB89 // 2953 + SYS_ATAND32 = 0xB8A // 2954 + SYS_ATAND64 = 0xB8B // 2955 + SYS_ATAND128 = 0xB8C // 2956 + SYS_ATAN2D32 = 0xB8D // 2957 + SYS_ATAN2D64 = 0xB8E // 2958 + SYS_ATAN2D128 = 0xB8F // 2959 + SYS_ATANHD32 = 0xB90 // 2960 + SYS_ATANHD64 = 0xB91 // 2961 + SYS_ATANHD128 = 0xB92 // 2962 + SYS_CBRTD32 = 0xB93 // 2963 + SYS_CBRTD64 = 0xB94 // 2964 + SYS_CBRTD128 = 0xB95 // 2965 + SYS_CEILD32 = 0xB96 // 2966 + SYS_CEILD64 = 0xB97 // 2967 + SYS_CEILD128 = 0xB98 // 2968 + SYS___CLASS2 = 0xB99 // 2969 + SYS___CLASS2_B = 0xB9A // 2970 + SYS___CLASS2_H = 0xB9B // 2971 + SYS_COPYSIGND32 = 0xB9C // 2972 + SYS_COPYSIGND64 = 0xB9D // 2973 + SYS_COPYSIGND128 = 0xB9E // 2974 + SYS_COSD32 = 0xB9F // 2975 + SYS_COSD64 = 0xBA0 // 2976 + SYS_COSD128 = 0xBA1 // 2977 + SYS_COSHD32 = 0xBA2 // 2978 + SYS_COSHD64 = 0xBA3 // 2979 + SYS_COSHD128 = 0xBA4 // 2980 + SYS_ERFD32 = 0xBA5 // 2981 + SYS_ERFD64 = 0xBA6 // 2982 + SYS_ERFD128 = 0xBA7 // 2983 + SYS_ERFCD32 = 0xBA8 // 2984 + SYS_ERFCD64 = 0xBA9 // 2985 + SYS_ERFCD128 = 0xBAA // 2986 + SYS_EXPD32 = 0xBAB // 2987 + SYS_EXPD64 = 0xBAC // 2988 + SYS_EXPD128 = 0xBAD // 2989 + SYS_EXP2D32 = 0xBAE // 2990 + SYS_EXP2D64 = 0xBAF // 2991 + SYS_EXP2D128 = 0xBB0 // 2992 + SYS_EXPM1D32 = 0xBB1 // 2993 + SYS_EXPM1D64 = 0xBB2 // 2994 + SYS_EXPM1D128 = 0xBB3 // 2995 + SYS_FABSD32 = 0xBB4 // 2996 + SYS_FABSD64 = 0xBB5 // 2997 + SYS_FABSD128 = 0xBB6 // 2998 + SYS_FDIMD32 = 0xBB7 // 2999 + SYS_FDIMD64 = 0xBB8 // 3000 + SYS_FDIMD128 = 0xBB9 // 3001 + SYS_FE_DEC_GETROUND = 0xBBA // 3002 + SYS_FE_DEC_SETROUND = 0xBBB // 3003 + SYS_FLOORD32 = 0xBBC // 3004 + SYS_FLOORD64 = 0xBBD // 3005 + SYS_FLOORD128 = 0xBBE // 3006 + SYS_FMAD32 = 0xBBF // 3007 + SYS_FMAD64 = 0xBC0 // 3008 + SYS_FMAD128 = 0xBC1 // 3009 + SYS_FMAXD32 = 0xBC2 // 3010 + SYS_FMAXD64 = 0xBC3 // 3011 + SYS_FMAXD128 = 0xBC4 // 3012 + SYS_FMIND32 = 0xBC5 // 3013 + SYS_FMIND64 = 0xBC6 // 3014 + SYS_FMIND128 = 0xBC7 // 3015 + SYS_FMODD32 = 0xBC8 // 3016 + SYS_FMODD64 = 0xBC9 // 3017 + SYS_FMODD128 = 0xBCA // 3018 + SYS___FP_CAST_D = 0xBCB // 3019 + SYS_FREXPD32 = 0xBCC // 3020 + SYS_FREXPD64 = 0xBCD // 3021 + SYS_FREXPD128 = 0xBCE // 3022 + SYS_HYPOTD32 = 0xBCF // 3023 + SYS_HYPOTD64 = 0xBD0 // 3024 + SYS_HYPOTD128 = 0xBD1 // 3025 + SYS_ILOGBD32 = 0xBD2 // 3026 + SYS_ILOGBD64 = 0xBD3 // 3027 + SYS_ILOGBD128 = 0xBD4 // 3028 + SYS_LDEXPD32 = 0xBD5 // 3029 + SYS_LDEXPD64 = 0xBD6 // 3030 + SYS_LDEXPD128 = 0xBD7 // 3031 + SYS_LGAMMAD32 = 0xBD8 // 3032 + SYS_LGAMMAD64 = 0xBD9 // 3033 + SYS_LGAMMAD128 = 0xBDA // 3034 + SYS_LLRINTD32 = 0xBDB // 3035 + SYS_LLRINTD64 = 0xBDC // 3036 + SYS_LLRINTD128 = 0xBDD // 3037 + SYS_LLROUNDD32 = 0xBDE // 3038 + SYS_LLROUNDD64 = 0xBDF // 3039 + SYS_LLROUNDD128 = 0xBE0 // 3040 + SYS_LOGD32 = 0xBE1 // 3041 + SYS_LOGD64 = 0xBE2 // 3042 + SYS_LOGD128 = 0xBE3 // 3043 + SYS_LOG10D32 = 0xBE4 // 3044 + SYS_LOG10D64 = 0xBE5 // 3045 + SYS_LOG10D128 = 0xBE6 // 3046 + SYS_LOG1PD32 = 0xBE7 // 3047 + SYS_LOG1PD64 = 0xBE8 // 3048 + SYS_LOG1PD128 = 0xBE9 // 3049 + SYS_LOG2D32 = 0xBEA // 3050 + SYS_LOG2D64 = 0xBEB // 3051 + SYS_LOG2D128 = 0xBEC // 3052 + SYS_LOGBD32 = 0xBED // 3053 + SYS_LOGBD64 = 0xBEE // 3054 + SYS_LOGBD128 = 0xBEF // 3055 + SYS_LRINTD32 = 0xBF0 // 3056 + SYS_LRINTD64 = 0xBF1 // 3057 + SYS_LRINTD128 = 0xBF2 // 3058 + SYS_LROUNDD32 = 0xBF3 // 3059 + SYS_LROUNDD64 = 0xBF4 // 3060 + SYS_LROUNDD128 = 0xBF5 // 3061 + SYS_MODFD32 = 0xBF6 // 3062 + SYS_MODFD64 = 0xBF7 // 3063 + SYS_MODFD128 = 0xBF8 // 3064 + SYS_NAND32 = 0xBF9 // 3065 + SYS_NAND64 = 0xBFA // 3066 + SYS_NAND128 = 0xBFB // 3067 + SYS_NEARBYINTD32 = 0xBFC // 3068 + SYS_NEARBYINTD64 = 0xBFD // 3069 + SYS_NEARBYINTD128 = 0xBFE // 3070 + SYS_NEXTAFTERD32 = 0xBFF // 3071 + SYS_NEXTAFTERD64 = 0xC00 // 3072 + SYS_NEXTAFTERD128 = 0xC01 // 3073 + SYS_NEXTTOWARDD32 = 0xC02 // 3074 + SYS_NEXTTOWARDD64 = 0xC03 // 3075 + SYS_NEXTTOWARDD128 = 0xC04 // 3076 + SYS_POWD32 = 0xC05 // 3077 + SYS_POWD64 = 0xC06 // 3078 + SYS_POWD128 = 0xC07 // 3079 + SYS_QUANTIZED32 = 0xC08 // 3080 + SYS_QUANTIZED64 = 0xC09 // 3081 + SYS_QUANTIZED128 = 0xC0A // 3082 + SYS_REMAINDERD32 = 0xC0B // 3083 + SYS_REMAINDERD64 = 0xC0C // 3084 + SYS_REMAINDERD128 = 0xC0D // 3085 + SYS___REMQUOD32 = 0xC0E // 3086 + SYS___REMQUOD64 = 0xC0F // 3087 + SYS___REMQUOD128 = 0xC10 // 3088 + SYS_RINTD32 = 0xC11 // 3089 + SYS_RINTD64 = 0xC12 // 3090 + SYS_RINTD128 = 0xC13 // 3091 + SYS_ROUNDD32 = 0xC14 // 3092 + SYS_ROUNDD64 = 0xC15 // 3093 + SYS_ROUNDD128 = 0xC16 // 3094 + SYS_SAMEQUANTUMD32 = 0xC17 // 3095 + SYS_SAMEQUANTUMD64 = 0xC18 // 3096 + SYS_SAMEQUANTUMD128 = 0xC19 // 3097 + SYS_SCALBLND32 = 0xC1A // 3098 + SYS_SCALBLND64 = 0xC1B // 3099 + SYS_SCALBLND128 = 0xC1C // 3100 + SYS_SCALBND32 = 0xC1D // 3101 + SYS_SCALBND64 = 0xC1E // 3102 + SYS_SCALBND128 = 0xC1F // 3103 + SYS_SIND32 = 0xC20 // 3104 + SYS_SIND64 = 0xC21 // 3105 + SYS_SIND128 = 0xC22 // 3106 + SYS_SINHD32 = 0xC23 // 3107 + SYS_SINHD64 = 0xC24 // 3108 + SYS_SINHD128 = 0xC25 // 3109 + SYS_SQRTD32 = 0xC26 // 3110 + SYS_SQRTD64 = 0xC27 // 3111 + SYS_SQRTD128 = 0xC28 // 3112 + SYS_STRTOD32 = 0xC29 // 3113 + SYS_STRTOD64 = 0xC2A // 3114 + SYS_STRTOD128 = 0xC2B // 3115 + SYS_TAND32 = 0xC2C // 3116 + SYS_TAND64 = 0xC2D // 3117 + SYS_TAND128 = 0xC2E // 3118 + SYS_TANHD32 = 0xC2F // 3119 + SYS_TANHD64 = 0xC30 // 3120 + SYS_TANHD128 = 0xC31 // 3121 + SYS_TGAMMAD32 = 0xC32 // 3122 + SYS_TGAMMAD64 = 0xC33 // 3123 + SYS_TGAMMAD128 = 0xC34 // 3124 + SYS_TRUNCD32 = 0xC3E // 3134 + SYS_TRUNCD64 = 0xC3F // 3135 + SYS_TRUNCD128 = 0xC40 // 3136 + SYS_WCSTOD32 = 0xC41 // 3137 + SYS_WCSTOD64 = 0xC42 // 3138 + SYS_WCSTOD128 = 0xC43 // 3139 + SYS___CODEPAGE_INFO = 0xC64 // 3172 + SYS_POSIX_OPENPT = 0xC66 // 3174 + SYS_PSELECT = 0xC67 // 3175 + SYS_SOCKATMARK = 0xC68 // 3176 + SYS_AIO_FSYNC = 0xC69 // 3177 + SYS_LIO_LISTIO = 0xC6A // 3178 + SYS___ATANPID32 = 0xC6B // 3179 + SYS___ATANPID64 = 0xC6C // 3180 + SYS___ATANPID128 = 0xC6D // 3181 + SYS___COSPID32 = 0xC6E // 3182 + SYS___COSPID64 = 0xC6F // 3183 + SYS___COSPID128 = 0xC70 // 3184 + SYS___SINPID32 = 0xC71 // 3185 + SYS___SINPID64 = 0xC72 // 3186 + SYS___SINPID128 = 0xC73 // 3187 + SYS_SETIPV4SOURCEFILTER = 0xC76 // 3190 + SYS_GETIPV4SOURCEFILTER = 0xC77 // 3191 + SYS_SETSOURCEFILTER = 0xC78 // 3192 + SYS_GETSOURCEFILTER = 0xC79 // 3193 + SYS_FWRITE_UNLOCKED = 0xC7A // 3194 + SYS_FREAD_UNLOCKED = 0xC7B // 3195 + SYS_FGETS_UNLOCKED = 0xC7C // 3196 + SYS_GETS_UNLOCKED = 0xC7D // 3197 + SYS_FPUTS_UNLOCKED = 0xC7E // 3198 + SYS_PUTS_UNLOCKED = 0xC7F // 3199 + SYS_FGETC_UNLOCKED = 0xC80 // 3200 + SYS_FPUTC_UNLOCKED = 0xC81 // 3201 + SYS_DLADDR = 0xC82 // 3202 + SYS_SHM_OPEN = 0xC8C // 3212 + SYS_SHM_UNLINK = 0xC8D // 3213 + SYS___CLASS2F = 0xC91 // 3217 + SYS___CLASS2L = 0xC92 // 3218 + SYS___CLASS2F_B = 0xC93 // 3219 + SYS___CLASS2F_H = 0xC94 // 3220 + SYS___CLASS2L_B = 0xC95 // 3221 + SYS___CLASS2L_H = 0xC96 // 3222 + SYS___CLASS2D32 = 0xC97 // 3223 + SYS___CLASS2D64 = 0xC98 // 3224 + SYS___CLASS2D128 = 0xC99 // 3225 + SYS___TOCSNAME2 = 0xC9A // 3226 + SYS___D1TOP = 0xC9B // 3227 + SYS___D2TOP = 0xC9C // 3228 + SYS___D4TOP = 0xC9D // 3229 + SYS___PTOD1 = 0xC9E // 3230 + SYS___PTOD2 = 0xC9F // 3231 + SYS___PTOD4 = 0xCA0 // 3232 + SYS_CLEARERR_UNLOCKED = 0xCA1 // 3233 + SYS_FDELREC_UNLOCKED = 0xCA2 // 3234 + SYS_FEOF_UNLOCKED = 0xCA3 // 3235 + SYS_FERROR_UNLOCKED = 0xCA4 // 3236 + SYS_FFLUSH_UNLOCKED = 0xCA5 // 3237 + SYS_FGETPOS_UNLOCKED = 0xCA6 // 3238 + SYS_FGETWC_UNLOCKED = 0xCA7 // 3239 + SYS_FGETWS_UNLOCKED = 0xCA8 // 3240 + SYS_FILENO_UNLOCKED = 0xCA9 // 3241 + SYS_FLDATA_UNLOCKED = 0xCAA // 3242 + SYS_FLOCATE_UNLOCKED = 0xCAB // 3243 + SYS_FPRINTF_UNLOCKED = 0xCAC // 3244 + SYS_FPUTWC_UNLOCKED = 0xCAD // 3245 + SYS_FPUTWS_UNLOCKED = 0xCAE // 3246 + SYS_FSCANF_UNLOCKED = 0xCAF // 3247 + SYS_FSEEK_UNLOCKED = 0xCB0 // 3248 + SYS_FSEEKO_UNLOCKED = 0xCB1 // 3249 + SYS_FSETPOS_UNLOCKED = 0xCB3 // 3251 + SYS_FTELL_UNLOCKED = 0xCB4 // 3252 + SYS_FTELLO_UNLOCKED = 0xCB5 // 3253 + SYS_FUPDATE_UNLOCKED = 0xCB7 // 3255 + SYS_FWIDE_UNLOCKED = 0xCB8 // 3256 + SYS_FWPRINTF_UNLOCKED = 0xCB9 // 3257 + SYS_FWSCANF_UNLOCKED = 0xCBA // 3258 + SYS_GETWC_UNLOCKED = 0xCBB // 3259 + SYS_GETWCHAR_UNLOCKED = 0xCBC // 3260 + SYS_PERROR_UNLOCKED = 0xCBD // 3261 + SYS_PRINTF_UNLOCKED = 0xCBE // 3262 + SYS_PUTWC_UNLOCKED = 0xCBF // 3263 + SYS_PUTWCHAR_UNLOCKED = 0xCC0 // 3264 + SYS_REWIND_UNLOCKED = 0xCC1 // 3265 + SYS_SCANF_UNLOCKED = 0xCC2 // 3266 + SYS_UNGETC_UNLOCKED = 0xCC3 // 3267 + SYS_UNGETWC_UNLOCKED = 0xCC4 // 3268 + SYS_VFPRINTF_UNLOCKED = 0xCC5 // 3269 + SYS_VFSCANF_UNLOCKED = 0xCC7 // 3271 + SYS_VFWPRINTF_UNLOCKED = 0xCC9 // 3273 + SYS_VFWSCANF_UNLOCKED = 0xCCB // 3275 + SYS_VPRINTF_UNLOCKED = 0xCCD // 3277 + SYS_VSCANF_UNLOCKED = 0xCCF // 3279 + SYS_VWPRINTF_UNLOCKED = 0xCD1 // 3281 + SYS_VWSCANF_UNLOCKED = 0xCD3 // 3283 + SYS_WPRINTF_UNLOCKED = 0xCD5 // 3285 + SYS_WSCANF_UNLOCKED = 0xCD6 // 3286 + SYS_ASCTIME64 = 0xCD7 // 3287 + SYS_ASCTIME64_R = 0xCD8 // 3288 + SYS_CTIME64 = 0xCD9 // 3289 + SYS_CTIME64_R = 0xCDA // 3290 + SYS_DIFFTIME64 = 0xCDB // 3291 + SYS_GMTIME64 = 0xCDC // 3292 + SYS_GMTIME64_R = 0xCDD // 3293 + SYS_LOCALTIME64 = 0xCDE // 3294 + SYS_LOCALTIME64_R = 0xCDF // 3295 + SYS_MKTIME64 = 0xCE0 // 3296 + SYS_TIME64 = 0xCE1 // 3297 + SYS___LOGIN_APPLID = 0xCE2 // 3298 + SYS___PASSWD_APPLID = 0xCE3 // 3299 + SYS_PTHREAD_SECURITY_APPLID_NP = 0xCE4 // 3300 + SYS___GETTHENT = 0xCE5 // 3301 + SYS_FREEIFADDRS = 0xCE6 // 3302 + SYS_GETIFADDRS = 0xCE7 // 3303 + SYS_POSIX_FALLOCATE = 0xCE8 // 3304 + SYS_POSIX_MEMALIGN = 0xCE9 // 3305 + SYS_SIZEOF_ALLOC = 0xCEA // 3306 + SYS_RESIZE_ALLOC = 0xCEB // 3307 + SYS_FREAD_NOUPDATE = 0xCEC // 3308 + SYS_FREAD_NOUPDATE_UNLOCKED = 0xCED // 3309 + SYS_FGETPOS64 = 0xCEE // 3310 + SYS_FSEEK64 = 0xCEF // 3311 + SYS_FSEEKO64 = 0xCF0 // 3312 + SYS_FSETPOS64 = 0xCF1 // 3313 + SYS_FTELL64 = 0xCF2 // 3314 + SYS_FTELLO64 = 0xCF3 // 3315 + SYS_FGETPOS64_UNLOCKED = 0xCF4 // 3316 + SYS_FSEEK64_UNLOCKED = 0xCF5 // 3317 + SYS_FSEEKO64_UNLOCKED = 0xCF6 // 3318 + SYS_FSETPOS64_UNLOCKED = 0xCF7 // 3319 + SYS_FTELL64_UNLOCKED = 0xCF8 // 3320 + SYS_FTELLO64_UNLOCKED = 0xCF9 // 3321 + SYS_FOPEN_UNLOCKED = 0xCFA // 3322 + SYS_FREOPEN_UNLOCKED = 0xCFB // 3323 + SYS_FDOPEN_UNLOCKED = 0xCFC // 3324 + SYS_TMPFILE_UNLOCKED = 0xCFD // 3325 + SYS___MOSERVICES = 0xD3D // 3389 + SYS___GETTOD = 0xD3E // 3390 + SYS_C16RTOMB = 0xD40 // 3392 + SYS_C32RTOMB = 0xD41 // 3393 + SYS_MBRTOC16 = 0xD42 // 3394 + SYS_MBRTOC32 = 0xD43 // 3395 + SYS_QUANTEXPD32 = 0xD44 // 3396 + SYS_QUANTEXPD64 = 0xD45 // 3397 + SYS_QUANTEXPD128 = 0xD46 // 3398 + SYS___LOCALE_CTL = 0xD47 // 3399 + SYS___SMF_RECORD2 = 0xD48 // 3400 + SYS_FOPEN64 = 0xD49 // 3401 + SYS_FOPEN64_UNLOCKED = 0xD4A // 3402 + SYS_FREOPEN64 = 0xD4B // 3403 + SYS_FREOPEN64_UNLOCKED = 0xD4C // 3404 + SYS_TMPFILE64 = 0xD4D // 3405 + SYS_TMPFILE64_UNLOCKED = 0xD4E // 3406 + SYS_GETDATE64 = 0xD4F // 3407 + SYS_GETTIMEOFDAY64 = 0xD50 // 3408 + SYS_BIND2ADDRSEL = 0xD59 // 3417 + SYS_INET6_IS_SRCADDR = 0xD5A // 3418 + SYS___GETGRGID1 = 0xD5B // 3419 + SYS___GETGRNAM1 = 0xD5C // 3420 + SYS___FBUFSIZE = 0xD60 // 3424 + SYS___FPENDING = 0xD61 // 3425 + SYS___FLBF = 0xD62 // 3426 + SYS___FREADABLE = 0xD63 // 3427 + SYS___FWRITABLE = 0xD64 // 3428 + SYS___FREADING = 0xD65 // 3429 + SYS___FWRITING = 0xD66 // 3430 + SYS___FSETLOCKING = 0xD67 // 3431 + SYS__FLUSHLBF = 0xD68 // 3432 + SYS___FPURGE = 0xD69 // 3433 + SYS___FREADAHEAD = 0xD6A // 3434 + SYS___FSETERR = 0xD6B // 3435 + SYS___FPENDING_UNLOCKED = 0xD6C // 3436 + SYS___FREADING_UNLOCKED = 0xD6D // 3437 + SYS___FWRITING_UNLOCKED = 0xD6E // 3438 + SYS__FLUSHLBF_UNLOCKED = 0xD6F // 3439 + SYS___FPURGE_UNLOCKED = 0xD70 // 3440 + SYS___FREADAHEAD_UNLOCKED = 0xD71 // 3441 + SYS___LE_CEEGTJS = 0xD72 // 3442 + SYS___LE_RECORD_DUMP = 0xD73 // 3443 + SYS_FSTAT64 = 0xD74 // 3444 + SYS_LSTAT64 = 0xD75 // 3445 + SYS_STAT64 = 0xD76 // 3446 + SYS___READDIR2_64 = 0xD77 // 3447 + SYS___OPEN_STAT64 = 0xD78 // 3448 + SYS_FTW64 = 0xD79 // 3449 + SYS_NFTW64 = 0xD7A // 3450 + SYS_UTIME64 = 0xD7B // 3451 + SYS_UTIMES64 = 0xD7C // 3452 + SYS___GETIPC64 = 0xD7D // 3453 + SYS_MSGCTL64 = 0xD7E // 3454 + SYS_SEMCTL64 = 0xD7F // 3455 + SYS_SHMCTL64 = 0xD80 // 3456 + SYS_MSGXRCV64 = 0xD81 // 3457 + SYS___MGXR64 = 0xD81 // 3457 + SYS_W_GETPSENT64 = 0xD82 // 3458 + SYS_PTHREAD_COND_TIMEDWAIT64 = 0xD83 // 3459 + SYS_FTIME64 = 0xD85 // 3461 + SYS_GETUTXENT64 = 0xD86 // 3462 + SYS_GETUTXID64 = 0xD87 // 3463 + SYS_GETUTXLINE64 = 0xD88 // 3464 + SYS_PUTUTXLINE64 = 0xD89 // 3465 + SYS_NEWLOCALE = 0xD8A // 3466 + SYS_FREELOCALE = 0xD8B // 3467 + SYS_USELOCALE = 0xD8C // 3468 + SYS_DUPLOCALE = 0xD8D // 3469 + SYS___CHATTR64 = 0xD9C // 3484 + SYS___LCHATTR64 = 0xD9D // 3485 + SYS___FCHATTR64 = 0xD9E // 3486 + SYS_____CHATTR64_A = 0xD9F // 3487 + SYS_____LCHATTR64_A = 0xDA0 // 3488 + SYS___LE_CEEUSGD = 0xDA1 // 3489 + SYS___LE_IFAM_CON = 0xDA2 // 3490 + SYS___LE_IFAM_DSC = 0xDA3 // 3491 + SYS___LE_IFAM_GET = 0xDA4 // 3492 + SYS___LE_IFAM_QRY = 0xDA5 // 3493 + SYS_ALIGNED_ALLOC = 0xDA6 // 3494 + SYS_ACCEPT4 = 0xDA7 // 3495 + SYS___ACCEPT4_A = 0xDA8 // 3496 + SYS_COPYFILERANGE = 0xDA9 // 3497 + SYS_GETLINE = 0xDAA // 3498 + SYS___GETLINE_A = 0xDAB // 3499 + SYS_DIRFD = 0xDAC // 3500 + SYS_CLOCK_GETTIME = 0xDAD // 3501 + SYS_DUP3 = 0xDAE // 3502 + SYS_EPOLL_CREATE = 0xDAF // 3503 + SYS_EPOLL_CREATE1 = 0xDB0 // 3504 + SYS_EPOLL_CTL = 0xDB1 // 3505 + SYS_EPOLL_WAIT = 0xDB2 // 3506 + SYS_EPOLL_PWAIT = 0xDB3 // 3507 + SYS_EVENTFD = 0xDB4 // 3508 + SYS_STATFS = 0xDB5 // 3509 + SYS___STATFS_A = 0xDB6 // 3510 + SYS_FSTATFS = 0xDB7 // 3511 + SYS_INOTIFY_INIT = 0xDB8 // 3512 + SYS_INOTIFY_INIT1 = 0xDB9 // 3513 + SYS_INOTIFY_ADD_WATCH = 0xDBA // 3514 + SYS___INOTIFY_ADD_WATCH_A = 0xDBB // 3515 + SYS_INOTIFY_RM_WATCH = 0xDBC // 3516 + SYS_PIPE2 = 0xDBD // 3517 + SYS_PIVOT_ROOT = 0xDBE // 3518 + SYS___PIVOT_ROOT_A = 0xDBF // 3519 + SYS_PRCTL = 0xDC0 // 3520 + SYS_PRLIMIT = 0xDC1 // 3521 + SYS_SETHOSTNAME = 0xDC2 // 3522 + SYS___SETHOSTNAME_A = 0xDC3 // 3523 + SYS_SETRESUID = 0xDC4 // 3524 + SYS_SETRESGID = 0xDC5 // 3525 + SYS_PTHREAD_CONDATTR_GETCLOCK = 0xDC6 // 3526 + SYS_FLOCK = 0xDC7 // 3527 + SYS_FGETXATTR = 0xDC8 // 3528 + SYS___FGETXATTR_A = 0xDC9 // 3529 + SYS_FLISTXATTR = 0xDCA // 3530 + SYS___FLISTXATTR_A = 0xDCB // 3531 + SYS_FREMOVEXATTR = 0xDCC // 3532 + SYS___FREMOVEXATTR_A = 0xDCD // 3533 + SYS_FSETXATTR = 0xDCE // 3534 + SYS___FSETXATTR_A = 0xDCF // 3535 + SYS_GETXATTR = 0xDD0 // 3536 + SYS___GETXATTR_A = 0xDD1 // 3537 + SYS_LGETXATTR = 0xDD2 // 3538 + SYS___LGETXATTR_A = 0xDD3 // 3539 + SYS_LISTXATTR = 0xDD4 // 3540 + SYS___LISTXATTR_A = 0xDD5 // 3541 + SYS_LLISTXATTR = 0xDD6 // 3542 + SYS___LLISTXATTR_A = 0xDD7 // 3543 + SYS_LREMOVEXATTR = 0xDD8 // 3544 + SYS___LREMOVEXATTR_A = 0xDD9 // 3545 + SYS_LSETXATTR = 0xDDA // 3546 + SYS___LSETXATTR_A = 0xDDB // 3547 + SYS_REMOVEXATTR = 0xDDC // 3548 + SYS___REMOVEXATTR_A = 0xDDD // 3549 + SYS_SETXATTR = 0xDDE // 3550 + SYS___SETXATTR_A = 0xDDF // 3551 + SYS_FDATASYNC = 0xDE0 // 3552 + SYS_SYNCFS = 0xDE1 // 3553 + SYS_FUTIMES = 0xDE2 // 3554 + SYS_FUTIMESAT = 0xDE3 // 3555 + SYS___FUTIMESAT_A = 0xDE4 // 3556 + SYS_LUTIMES = 0xDE5 // 3557 + SYS___LUTIMES_A = 0xDE6 // 3558 + SYS_INET_ATON = 0xDE7 // 3559 + SYS_GETRANDOM = 0xDE8 // 3560 + SYS_GETTID = 0xDE9 // 3561 + SYS_MEMFD_CREATE = 0xDEA // 3562 + SYS___MEMFD_CREATE_A = 0xDEB // 3563 + SYS_FACCESSAT = 0xDEC // 3564 + SYS___FACCESSAT_A = 0xDED // 3565 + SYS_FCHMODAT = 0xDEE // 3566 + SYS___FCHMODAT_A = 0xDEF // 3567 + SYS_FCHOWNAT = 0xDF0 // 3568 + SYS___FCHOWNAT_A = 0xDF1 // 3569 + SYS_FSTATAT = 0xDF2 // 3570 + SYS___FSTATAT_A = 0xDF3 // 3571 + SYS_LINKAT = 0xDF4 // 3572 + SYS___LINKAT_A = 0xDF5 // 3573 + SYS_MKDIRAT = 0xDF6 // 3574 + SYS___MKDIRAT_A = 0xDF7 // 3575 + SYS_MKFIFOAT = 0xDF8 // 3576 + SYS___MKFIFOAT_A = 0xDF9 // 3577 + SYS_MKNODAT = 0xDFA // 3578 + SYS___MKNODAT_A = 0xDFB // 3579 + SYS_OPENAT = 0xDFC // 3580 + SYS___OPENAT_A = 0xDFD // 3581 + SYS_READLINKAT = 0xDFE // 3582 + SYS___READLINKAT_A = 0xDFF // 3583 + SYS_RENAMEAT = 0xE00 // 3584 + SYS___RENAMEAT_A = 0xE01 // 3585 + SYS_RENAMEAT2 = 0xE02 // 3586 + SYS___RENAMEAT2_A = 0xE03 // 3587 + SYS_SYMLINKAT = 0xE04 // 3588 + SYS___SYMLINKAT_A = 0xE05 // 3589 + SYS_UNLINKAT = 0xE06 // 3590 + SYS___UNLINKAT_A = 0xE07 // 3591 + SYS_SYSINFO = 0xE08 // 3592 + SYS_WAIT4 = 0xE0A // 3594 + SYS_CLONE = 0xE0B // 3595 + SYS_UNSHARE = 0xE0C // 3596 + SYS_SETNS = 0xE0D // 3597 + SYS_CAPGET = 0xE0E // 3598 + SYS_CAPSET = 0xE0F // 3599 + SYS_STRCHRNUL = 0xE10 // 3600 + SYS_PTHREAD_CONDATTR_SETCLOCK = 0xE12 // 3602 + SYS_OPEN_BY_HANDLE_AT = 0xE13 // 3603 + SYS___OPEN_BY_HANDLE_AT_A = 0xE14 // 3604 + SYS___INET_ATON_A = 0xE15 // 3605 + SYS_MOUNT1 = 0xE16 // 3606 + SYS___MOUNT1_A = 0xE17 // 3607 + SYS_UMOUNT1 = 0xE18 // 3608 + SYS___UMOUNT1_A = 0xE19 // 3609 + SYS_UMOUNT2 = 0xE1A // 3610 + SYS___UMOUNT2_A = 0xE1B // 3611 + SYS___PRCTL_A = 0xE1C // 3612 + SYS_LOCALTIME_R2 = 0xE1D // 3613 + SYS___LOCALTIME_R2_A = 0xE1E // 3614 + SYS_OPENAT2 = 0xE1F // 3615 + SYS___OPENAT2_A = 0xE20 // 3616 + SYS___LE_CEEMICT = 0xE21 // 3617 + SYS_GETENTROPY = 0xE22 // 3618 + SYS_NANOSLEEP = 0xE23 // 3619 + SYS_UTIMENSAT = 0xE24 // 3620 + SYS___UTIMENSAT_A = 0xE25 // 3621 + SYS_ASPRINTF = 0xE26 // 3622 + SYS___ASPRINTF_A = 0xE27 // 3623 + SYS_VASPRINTF = 0xE28 // 3624 + SYS___VASPRINTF_A = 0xE29 // 3625 + SYS_DPRINTF = 0xE2A // 3626 + SYS___DPRINTF_A = 0xE2B // 3627 + SYS_GETOPT_LONG = 0xE2C // 3628 + SYS___GETOPT_LONG_A = 0xE2D // 3629 + SYS_PSIGNAL = 0xE2E // 3630 + SYS___PSIGNAL_A = 0xE2F // 3631 + SYS_PSIGNAL_UNLOCKED = 0xE30 // 3632 + SYS___PSIGNAL_UNLOCKED_A = 0xE31 // 3633 + SYS_FSTATAT_O = 0xE32 // 3634 + SYS___FSTATAT_O_A = 0xE33 // 3635 + SYS_FSTATAT64 = 0xE34 // 3636 + SYS___FSTATAT64_A = 0xE35 // 3637 + SYS___CHATTRAT = 0xE36 // 3638 + SYS_____CHATTRAT_A = 0xE37 // 3639 + SYS___CHATTRAT64 = 0xE38 // 3640 + SYS_____CHATTRAT64_A = 0xE39 // 3641 + SYS_MADVISE = 0xE3A // 3642 + +) diff --git a/vendor/github.com/ibmruntimes/go-recordio/v2/utils/textflag.h b/vendor/github.com/ibmruntimes/go-recordio/v2/utils/textflag.h new file mode 100644 index 00000000..dbf3d997 --- /dev/null +++ b/vendor/github.com/ibmruntimes/go-recordio/v2/utils/textflag.h @@ -0,0 +1,30 @@ +// Copyright 2013 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// This file defines flags attached to various functions +// and data objects. The compilers, assemblers, and linker must +// all agree on these values. + +// Don't profile the marked routine. This flag is deprecated. +#define NOPROF 1 +// It is ok for the linker to get multiple of these symbols. It will +// pick one of the duplicates to use. +#define DUPOK 2 +// Don't insert stack check preamble. +#define NOSPLIT 4 +// Put this data in a read-only section. +#define RODATA 8 +// This data contains no pointers. +#define NOPTR 16 +// This is a wrapper function and should not count as disabling 'recover'. +#define WRAPPER 32 +// This function uses its incoming context register. +#define NEEDCTXT 64 +// Allocate a word of thread local storage and store the offset from the +// thread local base to the thread local storage in this variable. +#define TLSBSS 256 +// Do not insert instructions to allocate a stack frame for this function. +// Only valid on functions that declare a frame size of 0. +// TODO(mwhudson): only implemented for ppc64x at present. +#define NOFRAME 512 diff --git a/vendor/github.com/ibmruntimes/go-recordio/v2/utils/utils.go b/vendor/github.com/ibmruntimes/go-recordio/v2/utils/utils.go new file mode 100644 index 00000000..f1b6f211 --- /dev/null +++ b/vendor/github.com/ibmruntimes/go-recordio/v2/utils/utils.go @@ -0,0 +1,513 @@ +//go:build zos +// +build zos + +package utils + +import ( + "bytes" + "fmt" + "reflect" + "runtime" + "unsafe" +) + +var Trace bool + +func Clib(offset uintptr, parms ...uintptr) (ret uintptr) { + ret = runtime.CallLeFuncByPtr(runtime.XplinkLibvec+offset<<4, parms) + return +} +func Cfunc(funcptr uintptr, parms ...uintptr) (ret uintptr) { + ret = runtime.CallLeFuncByPtr(funcptr, parms) + return +} +func CfuncEbcdic(funcptr uintptr, parms ...uintptr) (ret uintptr) { + runtime.LockOSThread() + defer runtime.UnlockOSThread() + ThreadEbcdicMode() + defer ThreadAsciiMode() + ret = runtime.CallLeFuncByPtr(funcptr, parms) + return +} +func ToCStringPointer(str string) uintptr { + return uintptr(unsafe.Pointer(&[]byte(str + "\x00")[0])) +} +func ThreadAsciiMode() { + Clib(0x791, 1) +} +func ThreadEbcdicMode() { + Clib(0x791, 0) +} +func Malloc64(size int) (ret unsafe.Pointer) { + ret = unsafe.Pointer(runtime.CallLeFuncByPtr(runtime.XplinkLibvec+SYS_MALLOC<<4, + []uintptr{uintptr(size)})) + runtime.CallLeFuncByPtr(runtime.XplinkLibvec+SYS_MEMSET<<4, []uintptr{uintptr(ret), 0, uintptr(size)}) + return +} +func Malloc31(size int) (ret unsafe.Pointer) { + ret = unsafe.Pointer(runtime.CallLeFuncByPtr(runtime.XplinkLibvec+SYS___MALLOC31<<4, + []uintptr{uintptr(size)})) + runtime.CallLeFuncByPtr(runtime.XplinkLibvec+SYS_MEMSET<<4, []uintptr{uintptr(ret), 0, uintptr(size)}) + return +} +func Malloc24(size int) (ret unsafe.Pointer) { + ret = unsafe.Pointer(runtime.CallLeFuncByPtr(runtime.XplinkLibvec+SYS___MALLOC24<<4, + []uintptr{uintptr(size)})) + runtime.CallLeFuncByPtr(runtime.XplinkLibvec+SYS_MEMSET<<4, []uintptr{uintptr(ret), 0, uintptr(size)}) + return +} +func Free(ptr unsafe.Pointer) { + runtime.CallLeFuncByPtr(runtime.XplinkLibvec+SYS_FREE<<4, + []uintptr{uintptr(ptr)}) +} + +func _etoA(record []byte) { + sz := len(record) + runtime.CallLeFuncByPtr(runtime.XplinkLibvec+SYS___E2A_L<<4, // __e2a_l + []uintptr{uintptr(unsafe.Pointer(&record[0])), uintptr(sz)}) +} + +func _atoE(record []byte) { + sz := len(record) + runtime.CallLeFuncByPtr(runtime.XplinkLibvec+SYS___A2E_L<<4, // __a2e_l + []uintptr{uintptr(unsafe.Pointer(&record[0])), uintptr(sz)}) +} + +var EtoA = _etoA +var AtoE = _atoE + +//go:noescape +func Bpxcall(plist []unsafe.Pointer, bpx_offset int64) + +//go:nosplit +func IefssreqX(parm unsafe.Pointer, branch_ptr unsafe.Pointer, save_area unsafe.Pointer) uintptr + +//go:nosplit +func Pc31(pcno uintptr, parm unsafe.Pointer) (rc uintptr, rn uintptr) + +//go:nosplit +func Svc8(r0 unsafe.Pointer, r1 uintptr) (rr0 unsafe.Pointer, rr1 uintptr, rr15 uintptr) + +//go:nosplit +func Svc9(EntryPointName unsafe.Pointer) (r15 uintptr) + +//go:nosplit +func Call24(p *ModuleInfo) uintptr + +//go:nosplit +func Call31(p *ModuleInfo) uintptr + +//go:nosplit +func Call64(p *ModuleInfo) uintptr + +//go:nosplit +func Deref(ptr uintptr) (value uintptr, error uintptr) + +func Iefssreq(parm unsafe.Pointer, dsa unsafe.Pointer) (ret uintptr) { + branch_ptr := unsafe.Pointer(uintptr(*(*int32)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Pointer(uintptr(0) + 16))) + 296))) + 20)))) + ret = IefssreqX(parm, branch_ptr, dsa) + return +} + +const ( + Amode24 = 1 + Amode31 = 2 + Amode64 = 3 +) + +type Thunk24 struct { + Sam24 uint16 + Basr uint16 + Sam64 uint16 + Loadr14 [3]uint16 + Br14 uint16 + _ uint16 + Braddr uintptr +} + +func (p *Thunk24) Init() { + p.Sam24 = 0x010c // sam24 + p.Basr = 0x0def // basr 14,15 + p.Sam64 = 0x010e // sam6 + p.Loadr14[0] = 0xc4e8 // lgrl 14,+8 + p.Loadr14[1] = 0x0000 + p.Loadr14[2] = uint16((uintptr(unsafe.Pointer(&p.Braddr)) - uintptr(unsafe.Pointer(&p.Loadr14[0]))) / 2) + p.Br14 = 0x07fe + +} +func (p *ModuleInfo) Free() { + if Trace { + fmt.Printf("Free(%v) ", *p) + } + rc := Svc9(unsafe.Pointer(&p.Modname[0])) + if Trace { + fmt.Printf(" rc %x \n", 0xffffffff&rc) + } + Free(unsafe.Pointer(p)) +} + +type ModuleInfo struct { + Modname [8]byte + Entry uintptr + R1 uintptr + R13 unsafe.Pointer + R15 uintptr + Amode uintptr + Thunk Thunk24 + DSA [144]byte +} + +func LoadMod(name string) (ret *ModuleInfo) { + if Trace { + fmt.Printf("LOAD %s\n", name) + } + var p *ModuleInfo + p = (*ModuleInfo)(Malloc24(int((reflect.TypeOf((*ModuleInfo)(nil)).Elem()).Size()))) + if uintptr(unsafe.Pointer(p)) == 0 { + if Trace { + fmt.Printf("Malloc24 failed\n") + } + return + } + copy(p.Modname[:], name) + if len(name) < 8 { + copy(p.Modname[len(name):], " ") + } + AtoE(p.Modname[:]) + var r0 unsafe.Pointer + var r1, r15 uintptr + r1 = 0x0000000080000000 + r0 = unsafe.Pointer(&(p.Modname[0])) + r0, r1, r15 = Svc8(r0, r1) + p.R15 = 0x00000000ffffffff & r15 // only lower 31 bit is meaningful + if p.R15 == 0 { + p.R1 = r1 + p.R13 = unsafe.Pointer(&p.DSA[0]) + if (0x01 & uintptr(r0)) == 0x01 { + if Trace { + fmt.Printf("AMODE 64\n") + } + p.Amode = Amode64 + p.Entry = uintptr(r0) & 0xfffffffffffffffe + } else if (0x0000000080000000 & uintptr(r0)) == 0x0000000080000000 { + if Trace { + fmt.Printf("AMODE 31\n") + } + p.Amode = Amode31 + p.Entry = uintptr(r0) & 0x000000007fffffff + } else { + if Trace { + fmt.Printf("AMODE 24\n") + } + p.Amode = Amode24 + p.Entry = uintptr(r0) & 0x000000007fffffff + p.Thunk.Init() + } + ret = p + } else { + if Trace { + fmt.Printf("svc 8 failed R15=%x\n", p.R15) + } + Free(unsafe.Pointer(p)) + } + return +} + +func (p *ModuleInfo) Call(plist uintptr) (ret uintptr) { + if Trace { + fmt.Printf("Call %x %x\n", p, plist) + } + p.R1 = plist + if Trace { + begin := uintptr(unsafe.Pointer(&p.Modname[0])) + fmt.Printf("Offsets__________\n") + fmt.Printf("Modename %d\n", 0) + fmt.Printf("Entry %d\n", uintptr(unsafe.Pointer(&p.Entry))-begin) + fmt.Printf("R1 %d\n", uintptr(unsafe.Pointer(&p.R1))-begin) + fmt.Printf("R13 %d\n", uintptr(unsafe.Pointer(&p.R13))-begin) + fmt.Printf("R15 %d\n", uintptr(unsafe.Pointer(&p.R15))-begin) + fmt.Printf("Amode %d\n", uintptr(unsafe.Pointer(&p.Amode))-begin) + fmt.Printf("Thunk.Sam24 %d\n", uintptr(unsafe.Pointer(&p.Thunk.Sam24))-begin) + fmt.Printf("Thunk.Br14 %d\n", uintptr(unsafe.Pointer(&p.Thunk.Br14))-begin) + fmt.Printf("Thunk.Braddr %d\n", uintptr(unsafe.Pointer(&p.Thunk.Braddr))-begin) + fmt.Printf("DSA %d\n", uintptr(unsafe.Pointer(&p.DSA[0]))-begin) + runtime.HexDump(uintptr(unsafe.Pointer(p)), (reflect.TypeOf((*ModuleInfo)(nil)).Elem()).Size()) + } + if p.Amode == Amode24 { + if Trace { + fmt.Printf("Call24\n") + } + ret = Call24(p) + } else if p.Amode == Amode31 { + if Trace { + fmt.Printf("Call31\n") + } + ret = Call31(p) + } else if p.Amode == Amode64 { + if Trace { + fmt.Printf("Call64\n") + } + ret = Call64(p) + } else { + if Trace { + fmt.Printf("Unknown AMODE\n") + p.R15 = 0xffffffffffffffff + } + ret = 0xffffffffffffffff + } + if Trace { + fmt.Printf("return %x\n", ret) + runtime.HexDump(uintptr(unsafe.Pointer(p)), (reflect.TypeOf((*ModuleInfo)(nil)).Elem()).Size()) + } + return +} + +// ConvertStringToSlice copies the string into the given slice. +// Always includeds a null terminator in the copy. +// Returns a new empty slice if the string doesn't fit. +func ConvertStringToSlice(s string, bi []byte) (bo []byte) { + size := len(s) + if size < cap(bi) { + copy(bi[:size], s) + bi[size] = 0 + return bi[:size+1] + } else { + return []byte{} + } +} + +// ConvertTypeToSlice returns a byte slice that shares storage +// with the incoming object of type T. The length of the slice +// will be exactly the size of the struct. +// Note: it isn't necessary to explicitly pass in the type T, +// as it can be inferred via the argument i. +func ConvertTypeToSlice[T any](i T) (slice []byte) { + var size int + var ptr unsafe.Pointer + ptr = unsafe.Pointer(reflect.ValueOf(i).Elem().UnsafeAddr()) + size = int(reflect.ValueOf(i).Elem().Type().Size()) + data := (*(*[1<<31 - 1]byte)(ptr))[:size] + return data +} + +// ConvertSliceToType returns a pointer to an object of type T. +// The pointer will share storage with the incoming byte slice "bi". +// The struct size is the second returned value. +// If the incoming slice isn't big enough, it returns . +func ConvertSliceToType[T1 any](bi []byte) (*T1, int) { + bip := (&bi[0]) + bipp := &bip + var t1p *T1 + t1pr := reflect.NewAt(reflect.ValueOf(t1p).Type(), unsafe.Pointer(bipp)).Elem().Interface() + size := int(unsafe.Sizeof(*(t1pr.(*T1)))) + return t1pr.(*T1), size +} + +// ConvertSliceToTypes is the same as / ConvertSliceToType, but with +// two objects of types T1 and T2, allocated contiguously in the slice +func ConvertSliceToTypes[T1, T2 any](bi []byte) (*T1, *T2) { + bip := (&bi[0]) + bipp := &bip + var t1p *T1 + t1pr := reflect.NewAt(reflect.ValueOf(t1p).Type(), unsafe.Pointer(bipp)).Elem().Interface() + size1 := unsafe.Sizeof(*(t1pr.(*T1))) + t2pr := unsafe.Pointer(uintptr(unsafe.Pointer(t1pr.(*T1))) + size1) + return t1pr.(*T1), (*T2)(t2pr) +} + +// ConvertSliceToTypes is the same as / ConvertSliceToType, but with +// three objects of types T1, T2, and T3, allocated contiguously in the slice +func ConvertSliceToTypes3[T1, T2, T3 any](bi []byte) (*T1, *T2, *T3) { + bip := (&bi[0]) + bipp := &bip + var t1p *T1 + t1pr := reflect.NewAt(reflect.ValueOf(t1p).Type(), unsafe.Pointer(bipp)).Elem().Interface() + size1 := unsafe.Sizeof(*(t1pr.(*T1))) + t2pr := unsafe.Pointer(uintptr(unsafe.Pointer(t1pr.(*T1))) + size1) + t2prb := (*T2)(t2pr) + size2 := unsafe.Sizeof(*(t2prb)) + t3pr := unsafe.Pointer(uintptr(unsafe.Pointer(t2prb)) + size2) + return t1pr.(*T1), (*T2)(t2pr), (*T3)(t3pr) +} + +// The equivalent of the perror() function which prints an error string on the "current" errno. +func Perror() { + runtime.CallLeFuncByPtr(runtime.XplinkLibvec+SYS___PERROR_A<<4, //perror() + []uintptr{}) +} + +// The equivalent of the dup2() function which duplicates a file descriptor +func Dup2(oldfd uintptr, newfd uintptr) uintptr { + ret := runtime.CallLeFuncByPtr(runtime.XplinkLibvec+SYS_DUP2<<4, + []uintptr{oldfd, newfd}) + return ret +} + +type Dll struct { + Dllname string + Handle uintptr + Count uint32 + TablePtr uintptr + Symbols map[string]uintptr + Valid bool +} + +func LeFuncName(funcptr uintptr) (name string) { + f, e := Deref(8 + funcptr) + if e != 0 { + return + } + h, e := Deref(f - 16) + if e != 0 { + return + } + if h != 0xc300c500c500f1 { + return + } + ppaoff, e := Deref(f - 8) + if e != 0 { + return + } + ppaoff >>= 32 + ppa1 := f - 16 + ppaoff + flags, e := Deref(ppa1 + 8) + if e != 0 { + return + } + flags >>= 32 + if 0 == (flags & 0x00000001) { + // no name + return + } + var optflds uintptr + if 0 != (flags & 0x00008000) { + // state variable locator + optflds++ + } + if 0 != (flags & 0x00004000) { + // arg area len + optflds++ + } + if 0 != (flags & 0x00003000) { + // fpr mask or ar mask + optflds++ + } + if 0 != (flags & 0x00000800) { + // member word + optflds++ + } + if 0 != (flags & 0x00000400) { + // ppa3 present + optflds++ + } + optflds <<= 2 + namesz1, e := Deref(ppa1 + 0x14 + optflds) + if e != 0 { + return + } + namesz1 >>= 48 + if namesz1 > 128 { + return + } + var funcname [128]byte + for i := 0; i < int(namesz1); i += 8 { + v, e := Deref(ppa1 + 0x16 + optflds + uintptr(i)) + if e != 0 { + return + } + funcname[i] = byte(v >> 56) + funcname[i+1] = byte(v >> 48) + funcname[i+2] = byte(v >> 40) + funcname[i+3] = byte(v >> 32) + funcname[i+4] = byte(v >> 24) + funcname[i+5] = byte(v >> 16) + funcname[i+6] = byte(v >> 8) + funcname[i+7] = byte(v) + } + runtime.CallLeFuncByPtr(runtime.XplinkLibvec+SYS___E2A_L<<4, // __e2a_l + []uintptr{uintptr(unsafe.Pointer(&funcname[0])), namesz1}) + name = string(funcname[:namesz1]) + return +} + +func (d *Dll) Open(name string) error { + d.Dllname = name + strptr := uintptr(unsafe.Pointer(&(([]byte(name + "\x00"))[0]))) + d.Handle = runtime.CallLeFuncByPtr(runtime.XplinkLibvec+SYS___DLOPEN_A<<4, []uintptr{strptr, uintptr(0x00010002)}) // dlopen_a + if d.Handle == 0 { + return fmt.Errorf("failed to open dll(1) %s, %s", name, d.Error()) + } + p1, e := Deref(d.Handle + 8) + if e != 0 { + runtime.CallLeFuncByPtr(runtime.XplinkLibvec+SYS_DLCLOSE<<4, []uintptr{d.Handle}) // dlclose + return fmt.Errorf("dll handle not valid(1) %s", name) + } + l, e := Deref(p1 + 152) + if e != 0 { + runtime.CallLeFuncByPtr(runtime.XplinkLibvec+SYS_DLCLOSE<<4, []uintptr{d.Handle}) // dlclose + return fmt.Errorf("dll handle not valid(2) %s", name) + } + if l != 0xc4d3c3c2000000a0 { + runtime.CallLeFuncByPtr(runtime.XplinkLibvec+SYS_DLCLOSE<<4, []uintptr{d.Handle}) // dlclose + return fmt.Errorf("missing dlcb marker %s", name) + } + l, e = Deref(p1 + 0x90) + if e != 0 { + runtime.CallLeFuncByPtr(runtime.XplinkLibvec+SYS_DLCLOSE<<4, []uintptr{d.Handle}) // dlclose + return fmt.Errorf("dll handle not valid(3) %s", name) + } + d.Count = uint32(l >> 32) + d.TablePtr, e = Deref(p1 + 0x78) + if e != 0 { + runtime.CallLeFuncByPtr(runtime.XplinkLibvec+SYS_DLCLOSE<<4, []uintptr{d.Handle}) // dlclose + return fmt.Errorf("dll handle not valid(4) %s", name) + } + d.Symbols = make(map[string]uintptr) + d.Valid = true + return nil +} +func (d *Dll) Close() error { + var res uintptr + if d.Valid { + res = runtime.CallLeFuncByPtr(runtime.XplinkLibvec+SYS_DLCLOSE<<4, []uintptr{d.Handle}) // dlclose + d.Valid = false + } + if res != 0 { + return fmt.Errorf("dll %s dlclose error: %s", d.Dllname, d.Error()) + } + return nil +} +func (d *Dll) Error() string { + str := runtime.CallLeFuncByPtr(runtime.XplinkLibvec+SYS___DLERROR_A<<4, []uintptr{d.Handle}) // dlerror + ba := (*[1<<30 - 1]byte)(unsafe.Pointer(str)) + size := bytes.IndexByte(ba[:], 0) + return string(ba[:size:size]) +} +func (d *Dll) Sym(fn string) (fptr uintptr, err error) { + fptr, ok := d.Symbols[fn] + if !ok { + fptr = runtime.CallLeFuncByPtr(runtime.XplinkLibvec+SYS___DLSYM_A<<4, []uintptr{d.Handle, uintptr(unsafe.Pointer(&(([]byte(fn + "\x00"))[0])))}) // dlsym + if fptr == 0 { + err = fmt.Errorf("Symbol %s not found: %s\n", fn, d.Error()) + } else { + d.Symbols[fn] = fptr + } + } + return +} +func (d *Dll) ResolveAll() error { + if !d.Valid { + return fmt.Errorf("DLL info not valid %s", d.Dllname) + } + entry := d.TablePtr + var i uint32 + for i = 0; i < d.Count; i++ { + fn := LeFuncName(entry) + if len(fn) != 0 { + d.Symbols[fn] = entry + } + entry += 16 + } + + return nil +} diff --git a/vendor/github.com/ibmruntimes/go-recordio/v2/utils/utils.s b/vendor/github.com/ibmruntimes/go-recordio/v2/utils/utils.s new file mode 100644 index 00000000..e7db216b --- /dev/null +++ b/vendor/github.com/ibmruntimes/go-recordio/v2/utils/utils.s @@ -0,0 +1,154 @@ +#include "go_asm.h" +#include "textflag.h" + +TEXT ·IefssreqX(SB), NOSPLIT|NOFRAME, $0 + MOVD g, R8 // R13-> R8 + MOVD R14, R9 // R14-> R9 + MOVD parm+0(FP), R1 // parm-> R1 + MOVD branch_ptr+8(FP), R7 // branch_ptr->R7 + MOVD dsa+16(FP), g // dsa-> R13 + MOVD R15, R10 // R15-> R10 + MOVD R7, R15 // branch_ptr -> R15 + BYTE $0x01; BYTE $0x0d // SAM31 + BYTE $0x05; BYTE $0xef // BALR 14,15 branch to IEFSSREQ + BYTE $0x01; BYTE $0x0e // SAM64 + MOVD R15, R7 // R15-> R7 (return value) + MOVD R10, R15 // restore R15 (so that FP is valid) + MOVD R7, ret+24(FP) // set return value + MOVD R8, g // restore R13 + MOVD R9, R14 // restore R14 + RET + +TEXT ·Bpxcall(SB), NOSPLIT|NOFRAME, $0 + MOVD plist_base+0(FP), R1 // r1 points to plist + MOVD bpx_offset+24(FP), R2 // r2 offset to BPX vector table + MOVD R14, R7 // save r14 + MOVD R15, R8 // save r15 + MOVWZ 16(R0), R9 + MOVWZ 544(R9), R9 + MOVWZ 24(R9), R9 // call vector in r9 + ADD R2, R9 // add offset to vector table + MOVWZ (R9), R9 // r9 points to entry point + BYTE $0x0D // BL R14,R9 --> basr r14,r9 + BYTE $0xE9 // clobbers 0,1,14,15 + MOVD R8, R15 // restore 15 + JMP R7 // return via saved return address + +TEXT ·Svc8(SB), NOSPLIT|NOFRAME, $0 + MOVD r0+0(FP), R0 // arg1-> R0 + MOVD r1+8(FP), R1 // arg2-> R1 + MOVD R15, R2 // save r15 + BYTE $0x0A // SVC 8 + BYTE $0x08 // ... + MOVD R15, R3 // R15->R3 + MOVD R2, R15 // restore R15 + MOVD R0, retr0+16(FP) + MOVD R1, retr1+24(FP) + MOVD R3, retr15+32(FP) + RET + +TEXT ·Svc9(SB), NOSPLIT|NOFRAME, $0 + MOVD r0+0(FP), R0 // arg1-> R0 + MOVD R15, R2 // save r15 + BYTE $0x0A // SVC 9 + BYTE $0x09 // ... + MOVD R15, R3 // R15->R3 + MOVD R2, R15 // restore R15 + MOVD R3, retr15+8(FP) + RET + +TEXT ·Call24(SB), NOSPLIT|NOFRAME, $0 + MOVD g, R8 // preserve R13,R14,R15 + MOVD R14, R9 + MOVD R15, R10 + MOVD modinfo+0(FP), R7 // arg1-> R0 + MOVD 16(R7), R1 + MOVD 24(R7), g + MOVD 8(R7), R15 + BYTE $0x0D // BASR 14,0 + BYTE $0xE0 + ADD $22, R14 // suppose to be address of label BACK + MOVD R14, 64(R7) // set the branch back adddress + MOVD $48(R7), R14 // R14 points to SAM24 + BYTE $0xEB; BYTE $0xEC; BYTE $0xD0; BYTE $0x48; BYTE $0x00; BYTE $0x26 // STMH r14,r12,72(r13) save higher half of register + BYTE $0x07; BYTE $0xFE // BR 14 + +BACK: + BYTE $0xEB; BYTE $0xEC; BYTE $0xD0; BYTE $0x48; BYTE $0x00; BYTE $0x96 // LMH r14,r12,72(r13) restore higher half of register + MOVD R15, 32(R7) // set p.R15 + MOVD R15, 16(R10) + MOVD R10, R15 + MOVD R9, R14 + MOVD R8, g + RET + +TEXT ·Call31(SB), NOSPLIT|NOFRAME, $0 + MOVD g, R8 // preserve R13,R14,R15 + MOVD R14, R9 + MOVD R15, R10 + MOVD modinfo+0(FP), R7 // arg1-> R0 + MOVD 16(R7), R1 + MOVD 24(R7), g + MOVD 8(R7), R15 + BYTE $0xEB; BYTE $0xEC; BYTE $0xD0; BYTE $0x48; BYTE $0x00; BYTE $0x26 // STMH r14,r12,72(r13) save higher half of register + BYTE $0x01; BYTE $0x0D // SAM31 + BYTE $0x0D; BYTE $0xEF // BASR 14,15 + BYTE $0x01; BYTE $0x0E // SAM64 + BYTE $0xEB; BYTE $0xEC; BYTE $0xD0; BYTE $0x48; BYTE $0x00; BYTE $0x96 // LMH r14,r12,72(r13) restore higher half of register + MOVD R15, 32(R7) // set p.R15 + MOVD R15, 16(R10) + MOVD R10, R15 + MOVD R9, R14 + MOVD R8, g + RET + +TEXT ·Call64(SB), NOSPLIT|NOFRAME, $0 + MOVD g, R8 // preserve R13,R14,R15 + MOVD R14, R9 + MOVD R15, R10 + MOVD modinfo+0(FP), R7 // arg1-> R0 + MOVD 16(R7), R1 + MOVD 24(R7), g + MOVD 8(R7), R15 + BYTE $0x0D; BYTE $0xEF // BASR 14,15 + MOVD R15, 32(R7) // set p.R15 + MOVD R15, 16(R10) + MOVD R10, R15 + MOVD R9, R14 + MOVD R8, g + RET + +TEXT ·Deref(SB), NOSPLIT, $0-24 + MOVD ptr+0(FP), R10 // test pointer in R10 + MOVD $0x0, R6 + BYTE $0xE3; BYTE $0x20; BYTE $0x04; BYTE $0xB8; BYTE $0x00; BYTE $0x17 // llgt 2,1208 + BYTE $0xB9; BYTE $0x17; BYTE $0x00; BYTE $0x22 // llgtr 2,2 + BYTE $0xA5; BYTE $0x26; BYTE $0x7F; BYTE $0xFF // nilh 2,32767 + BYTE $0xE3; BYTE $0x22; BYTE $0x00; BYTE $0x58; BYTE $0x00; BYTE $0x04 // lg 2,88(2) + BYTE $0xE3; BYTE $0x22; BYTE $0x00; BYTE $0x08; BYTE $0x00; BYTE $0x04 // lg 2,8(2) + BYTE $0x41; BYTE $0x22; BYTE $0x03; BYTE $0x68 // la 2,872(2) + BYTE $0xB9; BYTE $0x82; BYTE $0x00; BYTE $0x33 // xgr 3,3 + BYTE $0xA7; BYTE $0x55; BYTE $0x00; BYTE $0x04 // bras 5,lbl1 + BYTE $0xA7; BYTE $0x39; BYTE $0x00; BYTE $0x01 // lghi 3,1 + BYTE $0xB9; BYTE $0x02; BYTE $0x00; BYTE $0x33 // lbl1 ltgr 3,3 + BYTE $0xA7; BYTE $0x74; BYTE $0x00; BYTE $0x08 // brc b'0111',lbl2 + BYTE $0xE3; BYTE $0x52; BYTE $0x00; BYTE $0x00; BYTE $0x00; BYTE $0x24 // stg 5,0(2) + BYTE $0xE3; BYTE $0x6A; BYTE $0x00; BYTE $0x00; BYTE $0x00; BYTE $0x04 // lg 6,0(10) + BYTE $0xB9; BYTE $0x82; BYTE $0x00; BYTE $0x99 // lbl2 xgr 9,9 + BYTE $0xE3; BYTE $0x92; BYTE $0x00; BYTE $0x00; BYTE $0x00; BYTE $0x24 // stg 9,0(2) + MOVD R6, value+8(FP) // result in R6 + MOVD R3, error+16(FP) // error in R3 + RET + +TEXT ·Pc31(SB), NOSPLIT|NOFRAME, $0 + MOVD pcno+0(FP), R2 // pc number ->R2 + MOVD parm+8(FP), R1 // parm-> R1 + MOVD R15, R7 // R15-> R7 save R15 + BYTE $0x01; BYTE $0x0d // SAM31 + BYTE $0xB2; BYTE $0x18; BYTE $0x20; BYTE $0x00 // PC 0(2) + BYTE $0x01; BYTE $0x0e // SAM64 + MOVD R15, R8 // R15->R8 return code + MOVD R7, R15 // restore R15 (so that FP is valid) + MOVD R8, rc+16(FP) // return code + MOVD R0, rn+24(FP) // reason code if return code != 0 + RET diff --git a/vendor/modules.txt b/vendor/modules.txt index 4817c7d9..b9db39e4 100644 --- a/vendor/modules.txt +++ b/vendor/modules.txt @@ -512,6 +512,14 @@ github.com/grpc-ecosystem/go-grpc-middleware/validator github.com/grpc-ecosystem/grpc-gateway/v2/internal/httprule github.com/grpc-ecosystem/grpc-gateway/v2/runtime github.com/grpc-ecosystem/grpc-gateway/v2/utilities +# github.com/ibmdb/go_ibm_db v0.5.2 +## explicit; go 1.22.1 +github.com/ibmdb/go_ibm_db +github.com/ibmdb/go_ibm_db/api +github.com/ibmdb/go_ibm_db/log2 +# github.com/ibmruntimes/go-recordio/v2 v2.0.0-20240416213906-ae0ad556db70 +## explicit; go 1.18 +github.com/ibmruntimes/go-recordio/v2/utils # github.com/inconshreveable/mousetrap v1.1.0 ## explicit; go 1.18 github.com/inconshreveable/mousetrap