added missing files

This will allow the list to contain locations other than the source
tree.

.gitignore

@@ -0,0 +1,398 @@
+### Gradle ###
+.gradle
+build/
+
+# Ignore Gradle GUI config
+gradle-app.setting
+
+# Avoid ignoring Gradle wrapper jar file (.jar files are usually ignored)
+!gradle-wrapper.jar
+
+# Cache of project
+.gradletasknamecache
+
+# # Work around https://youtrack.jetbrains.com/issue/IDEA-116898
+# gradle/wrapper/gradle-wrapper.properties
+
+### Gradle Patch ###
+**/build/
+
+### Intellij ###
+# Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio and WebStorm
+# Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839
+
+# User-specific stuff
+.idea/**/workspace.xml
+.idea/**/tasks.xml
+.idea/**/usage.statistics.xml
+.idea/**/dictionaries
+.idea/**/shelf
+
+# Generated files
+.idea/**/contentModel.xml
+
+# Sensitive or high-churn files
+.idea/**/dataSources/
+.idea/**/dataSources.ids
+.idea/**/dataSources.local.xml
+.idea/**/sqlDataSources.xml
+.idea/**/dynamic.xml
+.idea/**/uiDesigner.xml
+.idea/**/dbnavigator.xml
+
+# Gradle
+.idea/**/gradle.xml
+.idea/**/libraries
+
+# Gradle and Maven with auto-import
+# When using Gradle or Maven with auto-import, you should exclude module files,
+# since they will be recreated, and may cause churn.  Uncomment if using
+# auto-import.
+# .idea/modules.xml
+# .idea/*.iml
+# .idea/modules
+# *.iml
+# *.ipr
+
+# CMake
+cmake-build-*/
+
+# Mongo Explorer plugin
+.idea/**/mongoSettings.xml
+
+# File-based project format
+*.iws
+
+# IntelliJ
+out/
+
+# mpeltonen/sbt-idea plugin
+.idea_modules/
+
+# JIRA plugin
+atlassian-ide-plugin.xml
+
+# Cursive Clojure plugin
+.idea/replstate.xml
+
+# Crashlytics plugin (for Android Studio and IntelliJ)
+com_crashlytics_export_strings.xml
+crashlytics.properties
+crashlytics-build.properties
+fabric.properties
+
+# Editor-based Rest Client
+.idea/httpRequests
+
+# Android studio 3.1+ serialized cache file
+.idea/caches/build_file_checksums.ser
+
+### Intellij Patch ###
+# Comment Reason: https://github.com/joeblau/gitignore.io/issues/186#issuecomment-215987721
+
+# *.iml
+# modules.xml
+# .idea/misc.xml
+# *.ipr
+
+# Sonarlint plugin
+.idea/sonarlint
+
+
+### Intellij+iml ###
+# Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio and WebStorm
+# Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839
+
+# User-specific stuff
+.idea/**/workspace.xml
+.idea/**/tasks.xml
+.idea/**/usage.statistics.xml
+.idea/**/dictionaries
+.idea/**/shelf
+
+# Generated files
+.idea/**/contentModel.xml
+
+# Sensitive or high-churn files
+.idea/**/dataSources/
+.idea/**/dataSources.ids
+.idea/**/dataSources.local.xml
+.idea/**/sqlDataSources.xml
+.idea/**/dynamic.xml
+.idea/**/uiDesigner.xml
+.idea/**/dbnavigator.xml
+
+# Gradle
+.idea/**/gradle.xml
+.idea/**/libraries
+
+# Gradle and Maven with auto-import
+# When using Gradle or Maven with auto-import, you should exclude module files,
+# since they will be recreated, and may cause churn.  Uncomment if using
+# auto-import.
+# .idea/modules.xml
+# .idea/*.iml
+# .idea/modules
+# *.iml
+# *.ipr
+
+# CMake
+cmake-build-*/
+
+# Mongo Explorer plugin
+.idea/**/mongoSettings.xml
+
+# File-based project format
+*.iws
+
+# IntelliJ
+out/
+
+# mpeltonen/sbt-idea plugin
+.idea_modules/
+
+# JIRA plugin
+atlassian-ide-plugin.xml
+
+# Cursive Clojure plugin
+.idea/replstate.xml
+
+# Crashlytics plugin (for Android Studio and IntelliJ)
+com_crashlytics_export_strings.xml
+crashlytics.properties
+crashlytics-build.properties
+fabric.properties
+
+# Editor-based Rest Client
+.idea/httpRequests
+
+# Android studio 3.1+ serialized cache file
+.idea/caches/build_file_checksums.ser
+
+### Intellij+iml Patch ###
+# Reason: https://github.com/joeblau/gitignore.io/issues/186#issuecomment-249601023
+
+*.iml
+modules.xml
+.idea/misc.xml
+*.ipr
+
+### Maven ###
+target/
+pom.xml.tag
+pom.xml.releaseBackup
+pom.xml.versionsBackup
+pom.xml.next
+release.properties
+dependency-reduced-pom.xml
+buildNumber.properties
+.mvn/timing.properties
+.mvn/wrapper/maven-wrapper.jar
+.flattened-pom.xml
+
+# CMake
+cmake-build-*/
+
+# Mongo Explorer plugin
+.idea/**/mongoSettings.xml
+
+# File-based project format
+*.iws
+
+# IntelliJ
+out/
+
+# mpeltonen/sbt-idea plugin
+.idea_modules/
+
+# JIRA plugin
+atlassian-ide-plugin.xml
+
+# Cursive Clojure plugin
+.idea/replstate.xml
+
+# Crashlytics plugin (for Android Studio and IntelliJ)
+com_crashlytics_export_strings.xml
+crashlytics.properties
+crashlytics-build.properties
+fabric.properties
+
+# Editor-based Rest Client
+.idea/httpRequests
+
+# Android studio 3.1+ serialized cache file
+.idea/caches/build_file_checksums.ser
+
+### Intellij Patch ###
+# Comment Reason: https://github.com/joeblau/gitignore.io/issues/186#issuecomment-215987721
+
+# *.iml
+# modules.xml
+# .idea/misc.xml
+# *.ipr
+
+# Sonarlint plugin
+.idea/sonarlint
+
+### Node ###
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+lerna-debug.log*
+.pnpm-debug.log*
+
+# Diagnostic reports (https://nodejs.org/api/report.html)
+report.[0-9]*.[0-9]*.[0-9]*.[0-9]*.json
+
+# Runtime data
+pids
+*.pid
+*.seed
+*.pid.lock
+
+# Directory for instrumented libs generated by jscoverage/JSCover
+lib-cov
+
+# Coverage directory used by tools like istanbul
+coverage
+*.lcov
+
+# nyc test coverage
+.nyc_output
+
+# Grunt intermediate storage (https://gruntjs.com/creating-plugins#storing-task-files)
+.grunt
+
+# Bower dependency directory (https://bower.io/)
+bower_components
+
+# node-waf configuration
+.lock-wscript
+
+# Compiled binary addons (https://nodejs.org/api/addons.html)
+build/Release
+
+# Dependency directories
+node_modules/
+jspm_packages/
+
+# Snowpack dependency directory (https://snowpack.dev/)
+web_modules/
+
+# TypeScript cache
+*.tsbuildinfo
+
+# Optional npm cache directory
+.npm
+
+# Optional eslint cache
+.eslintcache
+
+# Optional stylelint cache
+.stylelintcache
+
+# Microbundle cache
+.rpt2_cache/
+.rts2_cache_cjs/
+.rts2_cache_es/
+.rts2_cache_umd/
+
+# Optional REPL history
+.node_repl_history
+
+# Output of 'npm pack'
+*.tgz
+
+# Yarn Integrity file
+.yarn-integrity
+
+# dotenv environment variable files
+.env
+.env.development.local
+.env.test.local
+.env.production.local
+.env.local
+
+# parcel-bundler cache (https://parceljs.org/)
+.cache
+.parcel-cache
+
+# Next.js build output
+.next
+out
+
+# Nuxt.js build / generate output
+.nuxt
+dist
+
+# Gatsby files
+.cache/
+# Comment in the public line in if your project uses Gatsby and not Next.js
+# https://nextjs.org/blog/next-9-1#public-directory-support
+# public
+
+# vuepress build output
+.vuepress/dist
+
+# vuepress v2.x temp and cache directory
+.temp
+
+# Docusaurus cache and generated files
+.docusaurus
+
+# Serverless directories
+.serverless/
+
+# FuseBox cache
+.fusebox/
+
+# DynamoDB Local files
+.dynamodb/
+
+# TernJS port file
+.tern-port
+
+# Stores VSCode versions used for testing VSCode extensions
+.vscode-test
+
+# yarn v2
+.yarn/cache
+.yarn/unplugged
+.yarn/build-state.yml
+.yarn/install-state.gz
+.pnp.*
+
+### Node Patch ###
+# Serverless Webpack directories
+.webpack/
+
+# Optional stylelint cache
+
+# SvelteKit build / generate output
+.svelte-kit
+
+
+### yarn ###
+
+.yarn/*
+!.yarn/releases
+!.yarn/patches
+!.yarn/plugins
+!.yarn/sdks
+!.yarn/versions
+
+# if you are NOT using Zero-installs, then:
+# comment the following lines
+!.yarn/cache
+
+# and uncomment the following lines
+# .pnp.*
+
+### CVS ###
+/CVS/*
+**/CVS/*
+.cvsignore
+*/.cvsignore

CMakeLists.txt

@@ -0,0 +1,788 @@
+#################################################################
+#								#
+#	Copyright 2012, 2013 Fidelity Information Services, Inc	#
+#								#
+#	This source code contains the intellectual property	#
+#	of its copyright holder(s), and is made available	#
+#	under a license.  If you do not know the terms of	#
+#	the license, please stop and do not read further.	#
+#								#
+#################################################################
+
+# CMake 2.8.4 introduced LINK_DEPENDS target property
+# CMake 2.8.4 introduced generator expressions in custom commands
+# CMake 2.8.5 introduced use of C compiler as the assembler
+cmake_minimum_required(VERSION 2.8.5)
+project(GTM C ASM)
+
+# Max optimization level is -O2
+get_property(languages GLOBAL PROPERTY ENABLED_LANGUAGES)
+foreach(lang ${languages})
+  get_property(flags CACHE CMAKE_${lang}_FLAGS_RELEASE PROPERTY VALUE)
+  if("${flags}" MATCHES "-O[3-9]")
+    string(REGEX REPLACE "-O[3-9]" "-O2" flags "${flags}")
+    set_property(CACHE CMAKE_${lang}_FLAGS_RELEASE PROPERTY VALUE "${flags}")
+  endif()
+endforeach()
+
+# Defaults
+set(version V6.0-003)
+if("${version}" STREQUAL "")
+        set(version V9.9-0)
+endif()
+
+# If CMAKE_BUILD_TYPE is not defined make it a Release build
+if(NOT CMAKE_CONFIGURATION_TYPES AND NOT CMAKE_BUILD_TYPE)
+  set(CMAKE_BUILD_TYPE Release CACHE STRING "Build type" FORCE)
+endif()
+
+# If it's a debug build make sure GT.M uses all of its debug options
+set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -DDEBUG")
+
+set(install_permissions_script
+  OWNER_READ OWNER_EXECUTE OWNER_WRITE
+  GROUP_READ GROUP_EXECUTE
+  WORLD_READ WORLD_EXECUTE
+  )
+
+set_property(DIRECTORY APPEND PROPERTY COMPILE_DEFINITIONS_DEBUG DEBUG)
+
+# Only IA64 and x86_64 architectures use this option
+set(gen_xfer_desc 0)
+
+# Platform specific libs
+set(gtm_osarch_libs "")
+
+# Define these ahead of establishing platforms
+set(gt_src_list)
+set(sources_used "")
+set(extralibs "")
+set(is_encryption_supported 1)
+set(libmumpsrestoreregex "")
+message("--> OS = ${CMAKE_SYSTEM_NAME} / ARCH = ${CMAKE_SYSTEM_PROCESSOR}")
+# Establish platform
+# Except for Solaris, CMAKE_COMPILER_IS_GNUCC is true
+if("${CMAKE_SYSTEM_NAME}" MATCHES "Linux")
+  include(sr_linux/platform.cmake)
+elseif("${CMAKE_SYSTEM_NAME}" MATCHES "HP-UX")
+  include(sr_hpux/platform.cmake)
+elseif("${CMAKE_SYSTEM_NAME}" MATCHES "AIX")
+  include(sr_aix/platform.cmake)
+elseif("${CMAKE_SYSTEM_NAME}" MATCHES "SunOS")
+  include(sr_sun/platform.cmake)
+else()
+  message(FATAL_ERROR "--> OS = ${CMAKE_SYSTEM_NAME} / ARCH = ${CMAKE_SYSTEM_PROCESSOR}")
+endif()
+
+# Choose where to get bootstrap sources.
+set(GTM_DIST "" CACHE PATH "Existing GT.M Distribution")
+if(GTM_DIST)
+  # Bootstrap using already-installed mumps.
+  message(STATUS "Using existing gtm_dist=${GTM_DIST} to generate sources.")
+  set(gen_bootstrap 1)
+  set(gen_bootstrap_dist "${GTM_DIST}")
+  set(gen_bootstrap_mumps "${GTM_DIST}/mumps")
+  set(gen_bootstrap_depend "${gen_bootstrap_mumps}")
+else()
+  # Bootstrap using pre-generated bootstrap sources.
+  # We generate them again only for comparison.
+  set(gen_bootstrap 0)
+  set(gen_bootstrap_dist "${GTM_BINARY_DIR}")
+  set(gen_bootstrap_mumps "$<TARGET_FILE:mumps>")
+  set(gen_bootstrap_depend mumps)
+endif()
+
+set(GTM_INSTALL_DIR lib/fis-gtm/${version}_${arch} CACHE STRING "Install directory (under CMAKE_PREFIX_PATH if relative)")
+if(NOT GTM_INSTALL_DIR)
+  set(GTM_INSTALL_DIR .)
+endif()
+
+#-----------------------------------------------------------------------------
+
+# Source files are organized into subdirectories named by platform.
+# Store in 'gt_src_list' a list of directory names selected and
+# ordered based on the target platform.  A given source file name may
+# appear in multiple directories but only the instance found earliest
+# in the search path will be used.  Later instances of the same source
+# file name will be ignored.
+list(APPEND gt_src_list
+  sr_unix_gnp
+  sr_unix_cm
+  sr_unix
+  sr_port_cm
+  sr_port
+  )
+
+# Collect the source file names belonging to each directory.  Store
+# the full path to a directory in 'source_dir_${d}' and the list of
+# source file names in the directory in 'sources_${d}'.
+foreach(d ${gt_src_list})
+  set(source_dir_${d} ${GTM_SOURCE_DIR}/${d})
+  file(GLOB sources_${d} RELATIVE ${source_dir_${d}}
+	  ${d}/*.c ${d}/*.s ${d}/*.si)
+endforeach()
+if(gen_bootstrap)
+  # Prefer generated sources over all other locations.
+  set(gt_src_list gen ${gt_src_list})
+  set(source_dir_gen ${GTM_BINARY_DIR}/gen)
+  # Hard-code list since we cannot glob files that do not exist.
+  set(sources_gen cmerrors_ctl.c cmierrors_ctl.c gdeerrors_ctl.c merrors_ctl.c ttt.c)
+endif()
+
+# The C preprocessor include search path consists of every source
+# directory ordered by 'gt_src_list'.
+set(includes)
+foreach(d ${gt_src_list})
+  list(APPEND includes ${source_dir_${d}})
+endforeach()
+include_directories(${includes})
+# We generate some uniquely-named headers in the top of the build tree.
+include_directories(${GTM_BINARY_DIR})
+
+# Function to select the first instance of a given source file name
+# found in the ordered 'gt_src_list' search path.
+function(select_file src_var name)
+  set(found "")
+  foreach(d ${gt_src_list})
+    set(src "${source_dir_${d}}/${name}")
+    if(EXISTS "${src}")
+      set(found "${src}")
+      break()
+    endif()
+  endforeach()
+  if(NOT found)
+    message(FATAL_ERROR "Cannot find \"${name}\" as ${ARGN}")
+  endif()
+  set("${src_var}" "${found}" PARENT_SCOPE)
+endfunction()
+
+# Macro to search directories ordered by 'gt_src_list' for a given
+# list of source file names, assign them to a target, and exclude the
+# source file names from inclusion in libmumps.
+macro(set_source_list target)
+  foreach(name ${ARGN})
+    set(src "")
+    foreach(d ${gt_src_list})
+      if(";${sources_${d}};" MATCHES ";(${name}\\.(c|s|si));")
+      	set(fname ${CMAKE_MATCH_1})
+	set(src ${d}/${fname})
+	set("source_used_${fname}" 1)
+	list(APPEND sources_used ${source_dir_${d}}/${fname})
+	if(NOT "${libmumpsrestoreregex}" STREQUAL "")
+	  if(";${name};" MATCHES ";(${libmumpsrestoreregex});")
+	   set("source_used_${fname}" 0)
+          endif()
+        endif()
+	break()
+      endif()
+    endforeach()
+    if(src)
+      list(APPEND ${target}_SOURCES ${src})
+    else()
+      message(FATAL_ERROR "No source \"${name}\" available!")
+    endif()
+  endforeach()
+endmacro()
+
+# Macro like set_source_list but that loads the list of source file
+# names from a file.
+macro(load_source_list target listfile)
+  file(STRINGS "${listfile}" names)
+  set_source_list(${target} ${names})
+endmacro()
+
+#-----------------------------------------------------------------------------
+
+# Assign sources to libraries.
+load_source_list(libcmisockettcp sr_unix_gnp/libcmisockettcp.list)
+load_source_list(libdbcertify    sr_unix/libdbcertify.list)
+load_source_list(libdse          sr_unix/libdse.list)
+load_source_list(libgnpclient    sr_unix_gnp/libgnpclient.list)
+load_source_list(libgnpserver    sr_unix_gnp/libgnpserver.list)
+load_source_list(libgtcm         sr_unix_cm/libgtcm.list)
+load_source_list(liblke          sr_unix/liblke.list)
+load_source_list(libmupip        sr_unix/libmupip.list)
+load_source_list(libstub         sr_unix/libstub.list)
+if("${CMAKE_SYSTEM_NAME}" STREQUAL "SunOS")
+  load_source_list(libgtmrpc	sr_sun/libgtmrpc.list)
+endif()
+
+# Assign sources to executables.
+set_source_list(gtm_threadgbl_deftypes gtm_threadgbl_deftypes)
+set_source_list(dbcertify        dbcertify dbcertify_cmd)
+set_source_list(dse              dse dse_cmd)
+set_source_list(ftok             ftok)
+set_source_list(geteuid          geteuid)
+set_source_list(gtcm_gnp_server  gtcm_gnp_server)
+set_source_list(gtcm_pkdisp      gtcm_pkdisp)
+set_source_list(gtcm_play        gtcm_play omi_srvc_xct)
+set_source_list(gtcm_server      gtcm_main omi_srvc_xct)
+set_source_list(gtcm_shmclean    gtcm_shmclean)
+set_source_list(gtmsecshr        gtmsecshr_wrapper)
+set_source_list(gtmsecshr_real   gtmsecshr)
+set_source_list(libgtmcrypt      gtmcrypt_ref gtmcrypt_pk_ref gtmcrypt_dbk_ref)
+set_source_list(libgtmshr        gtm_main)
+set_source_list(lke              lke lke_cmd)
+set_source_list(maskpass         maskpass)
+set_source_list(mumps            gtm)
+set_source_list(mupip            mupip mupip_cmd)
+set_source_list(semstat2         semstat2)
+if("${CMAKE_SYSTEM_NAME}" STREQUAL "SunOS")
+  set_source_list(gtm_svc  	gtm_svc gtm_rpc_init gtm_dal_svc)
+endif()
+
+#-----------------------------------------------------------------------------
+# libmumps gets leftover sources, so compute the remaining list.
+set(source_used_dtgbldir.c 1) # exclude unused source
+set(libmumps_SOURCES "")
+foreach(d ${gt_src_list})
+  foreach(s ${sources_${d}})
+    if(NOT source_used_${s})
+      list(APPEND libmumps_SOURCES ${d}/${s})
+      set(source_used_${s} 1)
+      list(APPEND sources_used ${source_dir_${d}}/${s})
+    endif()
+  endforeach()
+endforeach()
+
+#-----------------------------------------------------------------------------
+# Generate files depending on gtm
+
+# Copy generation routines to a working directory.
+foreach(m chk2lev.m chkop.m gendash.m genout.m loadop.m loadvx.m msg.m tttgen.m tttscan.m)
+  add_custom_command(
+    OUTPUT gen/${m}
+    DEPENDS ${GTM_SOURCE_DIR}/sr_port/${m}
+    COMMAND ${CMAKE_COMMAND} -E copy ${GTM_SOURCE_DIR}/sr_port/${m} ${GTM_BINARY_DIR}/gen/${m}
+    )
+endforeach()
+
+foreach(f ttt.txt opcode_def.h vxi.h)
+  select_file(src ${f})
+  list(APPEND tttfiles ${src})
+endforeach()
+set(mumps_ttt_args -run tttgen ${tttfiles})
+add_custom_command(
+  OUTPUT gen/ttt.c
+  DEPENDS ${tttfiles}
+    gen/chk2lev.m gen/chkop.m gen/gendash.m gen/genout.m gen/loadop.m
+    gen/loadvx.m gen/tttgen.m gen/tttscan.m
+    ${GTM_SOURCE_DIR}/sr_unix/mumps.cmake ${gen_bootstrap_depend}
+  WORKING_DIRECTORY ${GTM_BINARY_DIR}/gen
+  COMMAND ${CMAKE_COMMAND}
+    -D gtm_dist=${gen_bootstrap_dist}
+    -D gtmroutines=.
+    -D mumps=${gen_bootstrap_mumps}
+    -D "args=${mumps_ttt_args}"
+    -D output_file=ttt.log
+    -P ${GTM_SOURCE_DIR}/sr_unix/mumps.cmake
+  VERBATIM
+  )
+list(APPEND gen_bootstrap_files gen/ttt.c)
+
+set(gen_merrors_extra gen/merrors_ansi.h)
+foreach(msg
+    sr_port/cmerrors.msg
+    sr_port/gdeerrors.msg
+    sr_port/merrors.msg
+    sr_unix_gnp/cmierrors.msg
+    )
+  get_filename_component(name ${msg} NAME_WE)
+  set(mumps_msg_args -run msg ${GTM_SOURCE_DIR}/${msg} unix)
+  set(outputs gen/${name}_ctl.c ${gen_${name}_extra})
+  add_custom_command(
+    OUTPUT ${outputs}
+    DEPENDS gen/msg.m ${GTM_SOURCE_DIR}/${msg}
+            ${GTM_SOURCE_DIR}/sr_unix/mumps.cmake ${gen_bootstrap_depend}
+    WORKING_DIRECTORY ${GTM_BINARY_DIR}/gen
+    COMMAND ${CMAKE_COMMAND}
+      -D gtm_dist=${gen_bootstrap_dist}
+      -D gtmroutines=.
+      -D mumps=${gen_bootstrap_mumps}
+      -D "args=${mumps_msg_args}"
+      -P ${GTM_SOURCE_DIR}/sr_unix/mumps.cmake
+    VERBATIM
+    )
+  list(APPEND gen_bootstrap_files ${outputs})
+endforeach()
+
+add_custom_target(gen_bootstrap ALL DEPENDS ${gen_bootstrap_files})
+
+#-----------------------------------------------------------------------------
+
+if(gen_xfer_desc)
+  list(SORT sources_used)
+  set(CMAKE_CONFIGURABLE_FILE_CONTENT "")
+  foreach(src ${sources_used})
+    set(CMAKE_CONFIGURABLE_FILE_CONTENT "${CMAKE_CONFIGURABLE_FILE_CONTENT}${src}\n")
+  endforeach()
+  configure_file(${CMAKE_ROOT}/Modules/CMakeConfigurableFile.in ${GTM_BINARY_DIR}/sources.list)
+  add_custom_command(
+    OUTPUT xfer_desc.i
+    WORKING_DIRECTORY ${GTM_BINARY_DIR}
+    DEPENDS ${GTM_SOURCE_DIR}/sr_unix/gen_xfer_desc.cmake
+            ${GTM_BINARY_DIR}/sources.list
+    COMMAND ${CMAKE_COMMAND}
+      -D CMAKE_C_COMPILER=${CMAKE_C_COMPILER}
+      -D "arch=${arch}"
+      -D "includes=${includes}"
+      -P ${GTM_SOURCE_DIR}/sr_unix/gen_xfer_desc.cmake
+    VERBATIM
+    )
+  add_custom_target(gen_xfer_desc DEPENDS xfer_desc.i)
+  if(gen_bootstrap)
+    add_dependencies(gen_xfer_desc gen_bootstrap)
+  endif()
+endif()
+
+#-----------------------------------------------------------------------------
+
+add_executable(gtm_threadgbl_deftypes ${gtm_threadgbl_deftypes_SOURCES})
+if(gen_xfer_desc)
+  add_dependencies(gtm_threadgbl_deftypes gen_xfer_desc)
+elseif(gen_bootstrap)
+  add_dependencies(gtm_threadgbl_deftypes gen_bootstrap)
+endif()
+
+add_custom_command(
+  OUTPUT gtm_threadgbl_deftypes.h
+  DEPENDS gtm_threadgbl_deftypes
+  COMMAND gtm_threadgbl_deftypes > gtm_threadgbl_deftypes.h.tmp
+  COMMAND ${CMAKE_COMMAND} -E rename gtm_threadgbl_deftypes.h.tmp gtm_threadgbl_deftypes.h
+  )
+add_custom_target(gen_gtm_threadgbl_deftypes DEPENDS gtm_threadgbl_deftypes.h)
+
+foreach(exp exe shr)
+  set(out gtm${exp}_symbols.export)
+  set(in ${GTM_SOURCE_DIR}/sr_unix/gtm${exp}_symbols.exp)
+  add_custom_command(
+    OUTPUT ${out}
+    DEPENDS ${in}
+    COMMAND tcsh -f ${GTM_SOURCE_DIR}/sr_linux/genexport.csh ${in} ${out}
+    )
+endforeach()
+
+add_custom_target(gen_export DEPENDS gtmexe_symbols.export gtmshr_symbols.export)
+
+foreach(lib
+  gtcm
+  cmisockettcp
+  gnpclient
+  gnpserver
+  dbcertify
+  dse
+  lke
+  mupip
+  stub
+  mumps
+  ${extralibs}
+  )
+  add_library(lib${lib} STATIC ${lib${lib}_SOURCES})
+  set_property(TARGET lib${lib} PROPERTY OUTPUT_NAME ${lib})
+  add_dependencies(lib${lib} gen_gtm_threadgbl_deftypes)
+endforeach()
+
+# TODO: find_package or find_library for system libs?
+include_directories ("/usr/local/include")
+target_link_libraries(libmumps		${libmumpslibs})
+
+add_executable(mumps			${mumps_SOURCES})
+target_link_libraries(mumps		libmumps)
+
+add_executable(dse			${dse_SOURCES})
+target_link_libraries(dse		libdse libmumps libstub)
+list(APPEND with_export dse)
+
+add_executable(dbcertify		${dbcertify_SOURCES})
+target_link_libraries(dbcertify		libdbcertify libmupip libmumps libstub)
+
+add_executable(geteuid			${geteuid_SOURCES})
+
+add_executable(gtmsecshr		${gtmsecshr_SOURCES})
+add_dependencies(gtmsecshr		gen_gtm_threadgbl_deftypes)
+
+add_executable(gtmsecshr_real		${gtmsecshr_real_SOURCES})
+target_link_libraries(gtmsecshr_real libmumps)
+set_target_properties(gtmsecshr_real PROPERTIES
+  OUTPUT_NAME gtmsecshr
+  RUNTIME_OUTPUT_DIRECTORY ${GTM_BINARY_DIR}/gtmsecshrdir
+  )
+add_dependencies(gtmsecshr_real		gen_gtm_threadgbl_deftypes)
+
+add_executable(mupip			${mupip_SOURCES})
+target_link_libraries(mupip		libmupip libmumps libstub)
+list(APPEND with_export mupip)
+
+add_executable(lke			${lke_SOURCES})
+target_link_libraries(lke		liblke libmumps libgnpclient libmumps libgnpclient libcmisockettcp)
+list(APPEND with_export lke)
+
+
+add_executable(gtcm_server		${gtcm_server_SOURCES})
+target_link_libraries(gtcm_server	libgtcm libmumps libstub)
+list(APPEND with_export gtcm_server)
+
+add_executable(gtcm_gnp_server		${gtcm_gnp_server_SOURCES})
+target_link_libraries(gtcm_gnp_server	libgnpserver liblke libmumps libcmisockettcp libstub)
+list(APPEND with_export gtcm_gnp_server)
+
+add_executable(gtcm_play		${gtcm_play_SOURCES})
+target_link_libraries(gtcm_play		libgtcm libmumps libstub)
+list(APPEND with_export gtcm_play)
+
+add_executable(gtcm_pkdisp		${gtcm_pkdisp_SOURCES})
+target_link_libraries(gtcm_pkdisp	libgtcm libmumps libstub)
+
+add_executable(gtcm_shmclean 		${gtcm_shmclean_SOURCES})
+target_link_libraries(gtcm_shmclean	libgtcm libmumps libstub)
+
+add_executable(semstat2		 	${semstat2_SOURCES})
+
+add_executable(ftok 			${ftok_SOURCES})
+target_link_libraries(ftok 		libmumps libstub)
+
+if("${CMAKE_SYSTEM_NAME}" STREQUAL "SunOS")
+  add_executable(gtm_svc		${gtm_svc_SOURCES})
+  target_link_libraries(gtm_svc		libmumps libgnpclient libcmisockettcp libgtmrpc)
+endif()
+foreach(t ${with_export})
+  set_target_properties(${t} PROPERTIES
+    LINK_FLAGS "${gtm_link}"
+    LINK_DEPENDS "${gtm_dep}"
+    )
+  add_dependencies(${t} gen_export)
+endforeach()
+
+add_library(libgtmshr MODULE ${libgtmshr_SOURCES})
+set_property(TARGET libgtmshr PROPERTY OUTPUT_NAME gtmshr)
+target_link_libraries(libgtmshr libmumps libgnpclient libcmisockettcp)
+set_target_properties(libgtmshr PROPERTIES
+  LINK_FLAGS "${libgtmshr_link}"
+  LINK_DEPENDS "${libgtmshr_dep}"
+  )
+add_dependencies(libgtmshr gen_export)
+add_dependencies(mumps libgtmshr)
+
+if(is_encryption_supported)
+  # Iterate over the list of GPG related libraries
+  foreach(gpglib gpg-error gpgme gcrypt)
+    # For each library, we need a new CMake variable, hence GPGLIB_${gpglib}
+    find_library(GPGLIB_${gpglib} NAME ${gpglib} PATHS ${CMAKE_LIBRARY_PATH})
+    # Append the found library to the list
+    set(GPG_LIBRARIES ${GPG_LIBRARIES} ${GPGLIB_${gpglib}})
+  endforeach()
+
+  add_library(libgtmcrypt MODULE ${libgtmcrypt_SOURCES})
+  set_target_properties(libgtmcrypt PROPERTIES
+    OUTPUT_NAME gtmcrypt
+    COMPILE_DEFINITIONS "USE_GCRYPT -DUSE_AES256CFB"
+    LIBRARY_OUTPUT_DIRECTORY ${GTM_BINARY_DIR}/plugin
+    )
+  target_link_libraries(libgtmcrypt ${GPG_LIBRARIES})
+  install(TARGETS libgtmcrypt DESTINATION ${GTM_INSTALL_DIR}/plugin)
+
+  add_executable(maskpass ${maskpass_SOURCES})
+  target_link_libraries(maskpass ${GPG_LIBRARIES})
+  set_target_properties(maskpass PROPERTIES
+    COMPILE_DEFINITIONS USE_GCRYPT
+    RUNTIME_OUTPUT_DIRECTORY ${GTM_BINARY_DIR}/plugin/gtmcrypt
+    )
+  install(TARGETS maskpass DESTINATION ${GTM_INSTALL_DIR}/plugin/gtmcrypt)
+
+  foreach(f
+      add_db_key.sh
+      build.sh
+      encrypt_sign_db_key.sh
+      gen_keypair.sh
+      gen_sym_hash.sh
+      gen_sym_key.sh
+      gtmcrypt.tab
+      gtmcrypt_dbk_ref.c
+      gtmcrypt_dbk_ref.h
+      gtmcrypt_interface.h
+      gtmcrypt_pk_ref.c
+      gtmcrypt_pk_ref.h
+      gtmcrypt_dbk_ref.c
+      gtmcrypt_dbk_ref.h
+      gtmcrypt_ref.c
+      gtmcrypt_ref.h
+      gtmcrypt_sym_ref.h
+      gtmxc_types.h
+      import_and_sign_key.sh
+      install.sh
+      maskpass.c
+      pinentry-gtm.sh
+      pinentry.m
+      pinentry.m
+      show_install_config.sh
+      )
+    set(f_in "${GTM_SOURCE_DIR}/sr_unix/${f}")
+    set(f_out "${GTM_BINARY_DIR}/plugin/gtmcrypt/${f}")
+    add_custom_command(
+      OUTPUT "${f_out}"
+      DEPENDS "${f_in}"
+      COMMAND ${CMAKE_COMMAND} -E copy "${f_in}" "${f_out}"
+      )
+    if("${f}" MATCHES "\\.sh$")
+      set(permissions PERMISSIONS ${install_permissions_script})
+    else()
+      set(permissions "")
+    endif()
+    install(FILES "${f_out}" DESTINATION ${GTM_INSTALL_DIR}/plugin/gtmcrypt ${permissions})
+    list(APPEND files_to_place "${f_out}")
+  endforeach()
+endif()
+
+install(TARGETS
+  mumps
+  dse
+  lke
+  geteuid
+  gtcm_server
+  gtcm_gnp_server
+  gtcm_pkdisp
+  gtcm_play
+  gtcm_shmclean
+  semstat2
+  ftok
+  gtmsecshr
+  mupip
+  libgtmshr
+  DESTINATION ${GTM_INSTALL_DIR}
+  )
+install(TARGETS gtmsecshr_real DESTINATION ${GTM_INSTALL_DIR}/gtmsecshrdir)
+
+# <r>.m -> <R>.m
+#file(GLOB m_files_sr_port RELATIVE ${GTM_SOURCE_DIR}/sr_port ${GTM_SOURCE_DIR}/sr_port/*.m)
+set(m_files_sr_port
+  gde.m
+  gdeadd.m
+  gdechang.m
+  gdedelet.m
+  gdeexit.m
+  gdehelp.m
+  gdeinit.m
+  gdelocks.m
+  gdelog.m
+  gdemap.m
+  gdemsgin.m
+  gdeparse.m
+  gdequit.m
+  gderenam.m
+  gdescan.m
+  gdesetgd.m
+  gdeshow.m
+  gdespawn.m
+  gdetempl.m
+  )
+file(GLOB m_files_sr_unix RELATIVE ${GTM_SOURCE_DIR}/sr_unix ${GTM_SOURCE_DIR}/sr_unix/*.m)
+file(GLOB mpt_files_sr_port RELATIVE ${GTM_SOURCE_DIR}/sr_port ${GTM_SOURCE_DIR}/sr_port/*.mpt)
+file(GLOB mpt_files_sr_unix RELATIVE ${GTM_SOURCE_DIR}/sr_unix ${GTM_SOURCE_DIR}/sr_unix/*.mpt)
+
+set(gtm_chset_dir_ "")
+set(gtm_chset_dir_UTF-8 "/utf8")
+
+foreach(d sr_port sr_unix)
+  foreach(m ${m_files_${d}})
+    get_filename_component(m_name "${m}" NAME_WE)
+    string(TOUPPER "${m_name}" m_upper)
+    if("${m}" MATCHES "^gde")
+      foreach(gtm_chset "" "UTF-8")
+        set(m_out "${GTM_BINARY_DIR}${gtm_chset_dir_${gtm_chset}}/${m_upper}.m")
+        add_custom_command(
+          OUTPUT "${m_out}"
+          DEPENDS ${GTM_SOURCE_DIR}/${d}/${m}
+          COMMAND ${CMAKE_COMMAND} -E copy ${GTM_SOURCE_DIR}/${d}/${m} "${m_out}"
+          )
+        list(APPEND files_to_place "${m_out}")
+        list(APPEND gtm_chset_routines_${gtm_chset} "${m_out}")
+      endforeach()
+    else()
+      set(m_out "${GTM_BINARY_DIR}/${m_upper}.m")
+      add_custom_command(
+        OUTPUT "${m_out}"
+        DEPENDS ${GTM_SOURCE_DIR}/${d}/${m}
+        COMMAND ${CMAKE_COMMAND} -E copy ${GTM_SOURCE_DIR}/${d}/${m} "${m_out}"
+        )
+      install(FILES "${m_out}" DESTINATION ${GTM_INSTALL_DIR})
+      list(APPEND files_to_place "${m_out}")
+    endif()
+  endforeach()
+  foreach(m ${mpt_files_${d}})
+    string(TOUPPER "_${m}" m_upper)
+    string(REGEX REPLACE "MPT$" "m" m_out "${GTM_BINARY_DIR}/${m_upper}")
+    add_custom_command(
+      OUTPUT "${m_out}"
+      DEPENDS ${GTM_SOURCE_DIR}/${d}/${m}
+      COMMAND ${CMAKE_COMMAND} -E copy ${GTM_SOURCE_DIR}/${d}/${m} "${m_out}"
+      )
+    install(FILES "${m_out}" DESTINATION ${GTM_INSTALL_DIR})
+    list(APPEND files_to_place "${m_out}")
+  endforeach()
+endforeach()
+
+set(files)
+foreach(f
+  gtm_descript.h
+  gtm_limits.h
+  gtm_sizeof.h
+  gtm_stdio.h
+  gtm_stdlib.h
+  gtm_string.h
+  gtm_strings.h
+  gtmxc_types.h
+  main_pragma.h
+  arch.gtc
+  gtcm_run.gtc
+  gtcm_slist.gtc
+  gdedefaults.gtc
+  gtmcshrc.gtc
+  gtmprofile.gtc
+  gtmprofile_preV54000.gtc
+  gtmstart.gtc
+  gtmstop.gtc
+  dse.hlp
+  gde.hlp
+  lke.hlp
+  mumps.hlp
+  mupip.hlp
+  custom_errors_sample.txt
+  )
+  select_file(src ${f})
+  list(APPEND files ${src})
+endforeach()
+install(FILES ${files} DESTINATION ${GTM_INSTALL_DIR})
+
+set(scripts)
+foreach(f
+  gtm.gtc
+  gtmbase.gtc
+  )
+  select_file(src ${f})
+  list(APPEND scripts ${src})
+endforeach()
+install(FILES ${scripts}
+  DESTINATION ${GTM_INSTALL_DIR}
+  PERMISSIONS ${install_permissions_script}
+  )
+
+find_program(ICUCONFIG NAMES icu-config)
+if(ICUCONFIG)
+  execute_process(
+    COMMAND ${ICUCONFIG} --version
+    OUTPUT_VARIABLE icu_version
+    RESULT_VARIABLE icu_failed
+    OUTPUT_STRIP_TRAILING_WHITESPACE
+    )
+  if(icu_failed)
+    message(FATAL_ERROR "Command\n ${ICUCONFIG} --version\nfailed (${icu_failed}).")
+  elseif("x${icu_version}" MATCHES "^x([0-9]+\\.[0-9]+)")
+    set(gtm_icu_version "${CMAKE_MATCH_1}")
+  else()
+    message(FATAL_ERROR "Command\n ${ICUCONFIG} --version\nproduced unrecognized output:\n ${icu_version}")
+  endif()
+else()
+  message(FATAL_ERROR "Unable to find 'icu-config'.  Set ICUCONFIG in CMake cache.")
+endif()
+
+if (gtm_icu_version GREATER 10)
+  message("libicu version ${gtm_icu_version} > 10")
+  string(REGEX REPLACE "([0-9])([0-9]).*" "\\1.\\2" gtm_icu_version "${gtm_icu_version}")
+  message("Fixing gtm_icu_version to ${gtm_icu_version}.\nThis had better be the default")
+endif()
+
+foreach(gtm_chset "" "UTF-8")
+  foreach(in ${gtm_chset_routines_${gtm_chset}})
+    string(REPLACE ".m" ".o" out "${in}")
+    get_filename_component(out_dir "${out}" PATH)
+    add_custom_command(
+      OUTPUT ${out}
+      DEPENDS ${in} ${GTM_SOURCE_DIR}/sr_unix/mumps.cmake mumps
+      COMMAND ${CMAKE_COMMAND}
+        -D gtm_dist=${GTM_BINARY_DIR}
+        -D gtmroutines=.
+        -D gtm_chset=${gtm_chset}
+        -D gtm_icu_version=${gtm_icu_version}
+        -D mumps=$<TARGET_FILE:mumps>
+        -D "args=${in}"
+        -P ${GTM_SOURCE_DIR}/sr_unix/mumps.cmake
+      WORKING_DIRECTORY ${out_dir}
+      VERBATIM
+      )
+    list(APPEND files_to_place ${out})
+    install(FILES "${out}" DESTINATION ${GTM_INSTALL_DIR}${gtm_chset_dir_${gtm_chset}})
+  endforeach()
+endforeach()
+
+#-----------------------------------------------------------------------------
+set(gtm_hlp mumps.hlp)
+set(gde_hlp gde.hlp)
+set(mupip_hlp mupip.hlp)
+set(dse_hlp dse.hlp)
+set(lke_hlp lke.hlp)
+foreach(help gtm gde mupip dse lke)
+  set(CMAKE_CONFIGURABLE_FILE_CONTENT
+    "Change -segment DEFAULT -block=2048 -file=\$gtm_dist/${help}help.dat
+Change -region DEFAULT -record=1020 -key=255
+exit")
+  configure_file(${CMAKE_ROOT}/Modules/CMakeConfigurableFile.in
+                 ${GTM_BINARY_DIR}/${help}help.in1)
+  set(CMAKE_CONFIGURABLE_FILE_CONTENT
+    "Do ^GTMHLPLD
+${GTM_SOURCE_DIR}/sr_port/${${help}_hlp}
+Halt")
+  configure_file(${CMAKE_ROOT}/Modules/CMakeConfigurableFile.in
+                 ${GTM_BINARY_DIR}/${help}help.in2)
+  set(env
+    -D gtm_dist=${GTM_BINARY_DIR}
+    -D gtmroutines=.
+    -D gtmgbldir=${GTM_BINARY_DIR}/${help}help
+    )
+  add_custom_command(
+    OUTPUT ${help}help.dat ${help}help.gld
+    DEPENDS ${GTM_SOURCE_DIR}/sr_unix/mumps.cmake mumps mupip
+            ${GTM_BINARY_DIR}/${help}help.in1
+            ${GTM_BINARY_DIR}/${help}help.in2
+    COMMAND ${CMAKE_COMMAND} -E remove ${help}help.dat ${help}help.gld
+    COMMAND ${CMAKE_COMMAND} ${env}
+      -D mumps=$<TARGET_FILE:mumps> -D "args=-run;GDE"
+      -D input_file=${GTM_BINARY_DIR}/${help}help.in1
+      -P ${GTM_SOURCE_DIR}/sr_unix/mumps.cmake
+    COMMAND ${CMAKE_COMMAND} ${env}
+      -D mumps=$<TARGET_FILE:mupip> -D "args=create"
+      -P ${GTM_SOURCE_DIR}/sr_unix/mumps.cmake
+    COMMAND ${CMAKE_COMMAND} ${env}
+      -D mumps=$<TARGET_FILE:mumps> -D "args=-direct"
+      -D input_file=${GTM_BINARY_DIR}/${help}help.in2
+      -P ${GTM_SOURCE_DIR}/sr_unix/mumps.cmake
+    VERBATIM
+    )
+  list(APPEND files_to_place ${help}help.dat)
+  install(FILES ${GTM_BINARY_DIR}/${help}help.dat DESTINATION ${GTM_INSTALL_DIR})
+endforeach()
+#-----------------------------------------------------------------------------
+
+set(GTM_TOP "${GTM_BINARY_DIR}")
+configure_file(sr_unix/gpgagent.tab.in plugin/gpgagent.tab @ONLY)
+set(GTM_TOP "${CMAKE_INSTALL_PREFIX}/${GTM_INSTALL_DIR}")
+configure_file(sr_unix/gpgagent.tab.in CMakeFiles/plugin/gpgagent.tab @ONLY)
+install(FILES ${GTM_BINARY_DIR}/CMakeFiles/plugin/gpgagent.tab DESTINATION ${GTM_INSTALL_DIR}/plugin)
+
+install(FILES sr_unix/configure.gtc DESTINATION ${GTM_INSTALL_DIR}
+  PERMISSIONS ${install_permissions_script}
+  RENAME configure
+  )
+
+install(FILES sr_unix/gtminstall.sh DESTINATION ${GTM_INSTALL_DIR}
+  PERMISSIONS ${install_permissions_script}
+  RENAME gtminstall
+  )
+
+install(FILES sr_unix/lowerc_cp.sh DESTINATION ${GTM_INSTALL_DIR}
+  RENAME lowerc_cp
+  )
+
+install(FILES COPYING DESTINATION ${GTM_INSTALL_DIR})
+
+add_custom_target(place_files ALL DEPENDS ${files_to_place})
+

CVS/Entries

@@ -0,0 +1,15 @@
+/CMakeLists.txt/1.6/Wed Oct 23 03:49:20 2013//
+/COPYING/1.6/Fri Nov  2 03:00:12 2012//
+/README/1.21/Wed Oct 23 03:49:20 2013//
+D/sr_alpha////
+D/sr_i386////
+D/sr_linux////
+D/sr_port////
+D/sr_port_cm////
+D/sr_unix////
+D/sr_unix_cm////
+D/sr_unix_gnp////
+D/sr_unix_nsb////
+D/sr_vvms////
+D/sr_x86_64////
+D/sr_x86_regs////

CVS/Entries.Extra

@@ -0,0 +1,15 @@
+/CMakeLists.txt////*////
+/COPYING////*////
+/README////*////
+D/sr_alpha////////
+D/sr_i386////////
+D/sr_linux////////
+D/sr_port////////
+D/sr_port_cm////////
+D/sr_unix////////
+D/sr_unix_cm////////
+D/sr_unix_gnp////////
+D/sr_unix_nsb////////
+D/sr_vvms////////
+D/sr_x86_64////////
+D/sr_x86_regs////////

CVS/Entries.Extra.Old

@@ -0,0 +1,3 @@
+/CMakeLists.txt////*////
+/COPYING////*////
+/README////*////

CVS/Entries.Old

@@ -0,0 +1,4 @@
+/CMakeLists.txt/1.6/Wed Oct 23 03:49:20 2013//
+/COPYING/1.6/Fri Nov  2 03:00:12 2012//
+/README/1.21/Wed Oct 23 03:49:20 2013//
+D

CVS/Repository

@@ -0,0 +1 @@
+gtm

CVS/Root

@@ -0,0 +1 @@
+:pserver:anonymous@fis-gtm.cvs.sourceforge.net:/cvsroot/fis-gtm

README

@@ -1,115 +1,90 @@
 All software in this package is part of FIS GT.M (http://fis-gtm.com)
-which is Copyright 2012 Fidelity Information Services, Inc., and
+which is Copyright 2013 Fidelity Information Services, Inc., and
 provided to you under the terms of a license. If there is a COPYING
 file included in this package, it contains the terms of the license under
 which the package is provided to you. If there is not a COPYING file in
 the package, you must ensure that your use of FIS GT.M complies with the
 license under which it is provided. If you are unsure as to the terms of
-your license, please consult with the entity that provided you with the package.
+your license, please consult with the entity that provided you with the
+package.
 
-The make file enclosed (sr_unix/comlist.mk) will build GT.M from source.  
+GT.M relies on CMake to generate the Makefiles to build GT.M from source. The
-The prerequisites are GNU make, GT.M binary installation (which you can
+prerequisites are CMake (at least 2.8.5), GNU make (at least 3.81), Linux
-download from http://sourceforge.net/projects/fis-gtm/), Linux x86, tcsh,
+(either x86 or x86_64), Unicode include files and GPG. Unicode include files
-Unicode and GPG include files. Unicode include files are automatically 
+are automatically installed if ICU is installed. GPG include files require
-installed if ICU is installed. GPG include files require installing the
+installing the GNUPG and related library development packages. Debian 6, Ubuntu
-GNUPG and related library development packages. GNU make 3.81, 
+12.04 LTS and RHEL 6.0 were used to do the test builds for this distribution.
-Ubuntu 10.04 LTS and RHEL 5.0 were used to do the test builds for this 
+The default ICU and GPG packages were taken from the distribution repositories.
-distribution.  The default ICU and GPG packages were taken from the OS
-vendors' repositories.
 
-To build a production version GT.M for linux do the following steps:
+To build GT.M for Linux, do the following steps:
-1. Fulfill the pre-requisites.
+
-   Download and install GT.M binary distribution from SourceForge if you
+1. Fulfill the pre-requisites
-   do not have GT.M installed already. The build procedure needs an
+   Install developement libraries libelf, zlib, libicu, libgpgme, libgpg-error,
-   existing GT.M mumps installed on the machine.
+   libgcrypt.
+
+   Ensure that your locale settings are correct, otherwise you will see
+   GTM-E-NONUTF8LOCALE messages. Refer the Messages and Recovery Procedures
+   Manual if you do encounter these messages.
+
+   [optional] The GT.M source tarball includes pre-generated files. To generate
+   these files requires a binary distribution of GT.M.  You can download GT.M
+   from http://sourceforge.net/projects/fis-gtm/ Unpack the tar file and run
+   the configure script as root. Note: the tar file unpacks everything into
+   your current working directory, not a new subdirectory. The Linux Standard
+   Base (LSB) install path for GT.M V6.0-003 is /opt/fis-gtm/V6.0-003_i686 or
+   /opt/fis-gtm/V6.0-003_x8664. These instrcutions are written using x8664, please
+   use i686 as necessary.
+
+   $ tar xfz gtm_V60003_linux_x8664_pro.tar.gz
+
+   # Note down the installation path for use with cmake below
 
-   You can download GT.M from http://sourceforge.net/projects/fis-gtm/
-   Unpack the tar file and run the configure script as root. Note: the tar
-   file unpacks everything into your current working directory, not a new
-   subdirectory. The Linux Standard Base (LSB) install path for GT.M 
-   V54002 is /opt/lsb-gtm/V5.4-002_i686 or /opt/lsb-gtm/V5.4-002_x8664.
-   $ tar xfz gtm_V54002_linux_i686_src.tar.gz
    $ sudo sh ./configure
 
 2. Unpack the GT.M sources
-   Change directory in the directory that you will place the GT.M source,
+   The GT.M source tarball extracts to a directory with the version number in
-   here after referred to as <gtm-directory>.
+   the name, fis-gtm-V6.0-003
-   $ mkdir <gtm-directory>
+   $ tar xfz fis-gtm-V6.0-003.tar.gz
-   $ cd <gtm-directory>
+   $ cd fis-gtm-V6.0-003
-   $ tar xfz gtm_V54002_linux_i686_src.tar.gz
 
-   You should find this README, COPYING file and sr_* source directroies.
+   You should find this README, LICENSE, COPYING and CMakeLists.txt file and
+   sr_* source directories.
 
-3. Define environment variables needed to build GT.M
+3. Building GT.M -
-   You will need to use tcsh to build GT.M.  GT.M uses several csh script
+   <fis-gtm-build> can be a sub directory of the source directory,
-   files the define environment variables used in the build process.  You
+   fis-gtm-V6.0-003, or any other valid path.
-   will need to define several variables prior to intiating your GT.M build.
 
-   - Define 'gtm_curpro' and 'gtm_exe' so that you can compile M programs.
+   $ mkdir <fis-gtm-build>
-   This is the directory in which you installed the GT.M binaries from
+   $ cd <fis-gtm-build>
-   SourceForge.
-   $ setenv gtm_curpro <path to installed GT.M>
-   $ setenv gtm_exe $gtm_curpro
-   $ setenv HOSTOS `uname -s`
 
-   - Define 'gtm_tools' and 'gtm_inc'
+   # [optional] If you installed GT.M, provide the directory path to cmake
-   $ setenv gtm_tools $PWD/sr_linux
+   #   -D GTM_DIST:PATH=$gtm_dist
-   $ setenv gtm_inc $PWD/sr_linux
+   #
+   # By default the build produces release versions of GT.M. To build a debug
+   # version of GT.M supply the following parameter to cmake
+   #     -D CMAKE_BUILD_TYPE=DEBUG
+   #
+   # Note that the cmake install does not create the final installed GT.M.
+   # Instead, it stages GT.M for distribution. Change the CMAKE_INSTALL_PREFIX
+   # to place the staged files in a local directory. To install GT.M, you must
+   # cd to that installed directory and execute the configure script.
+   #
+   #     -D CMAKE_INSTALL_PREFIX:PATH=${PWD}/package
+   #
+   $ cmake <path to>/fis-gtm-V6.0-003 -D CMAKE_INSTALL_PREFIX:PATH=${PWD}/package
 
-   - [OPTIONAL] Ubuntu users must define 'distro'
+   $ make
-   $ setenv distro ubuntu
 
-   - [OPTIONAL] By default the build procedure will build 64 bit version of
+   $ make install
-   GT.M on a x86_64 bit machine.
-   If you intend to build 32 bit version of GT.M on a x86_64 bit machine you
-   have to explicitly set the environment variable 'OBJECT_MODE' to '32'
-   $ setenv OBJECT_MODE 32
 
-   - Specify which ICU version is installed.
+   $ cd package/lib/fis-gtm/V6.0-003_x86_64
-   ICU version needs to be of the form #.#  If the result of running
-   "icu-config --version" has the form #.#.#, just use the first two
-   parts.  For example, if "icu-config --version" returns 3.8.1, use
-   3.8 in the  "setenv" step. 
-   $ icu-config --version
-   $ setenv gtm_icu_version <result of previous step>
 
-   - Define 'gtm_version_change' and execute gtm_env.csh
+   # Now you are ready to install GT.M. Answer a few questions and install it.
-   $ setenv gtm_version_change 1
+   # The recommended installation path is /opt/fis-gtm/V6.0-003_x86_64
-   $ source sr_unix/gtm_env.csh
 
-4. Building GT.M -
+   $ sudo ./configure
 
-By default, the gmake will build a production version GT.M. The build type
+   $ make clean
-of GT.M can be controlled by a parameter "buildtypes" - dbg (debug),
-bta (beta), and pro (production).  Passing a subset of dbg, bta, or pro in
-"buildtypes" from the environment or the command line will build that subset.
-For example:
-
-	gmake -f sr_unix/comlist.mk -I./sr_unix -I./sr_linux buildtypes=dbg gtm_ver=$PWD
-
-will build just a debuggable GT.M release.
-
-You can clean your builds by appending 'clean' to the make line.
-For example:
-	gmake -f sr_unix/comlist.mk -I./sr_unix -I./sr_linux buildtypes=dbg gtm_ver=$PWD clean
-
-5. Packaging GT.M -
-
-Once the required builds have been done the object distribution can be
-tar'ed by doing:
-
-	gmake -f sr_unix/comlist.mk -I./sr_unix -I./sr_linux gtm_ver=$PWD package
-
-Again, buildtypes can be used to package just a subset. For example:
-
-	gmake -f sr_unix/comlist.mk -I./sr_unix -I./sr_linux buildtypes=pro gtm_ver=$PWD package
-
-Appendix: Known warnings and errors
-  - "cc1: note: obsolete option -I- used, please use -iquote instead"
-  You can safely ignore this warning
-
-  - "chk2lev.mdep:2: *** missing separator.  Stop."
-  tcsh is using the builtin echo, you need to set the environment variable
-  'distro' to 'ubuntu' and clean your build.
-  $ setenv distro ubuntu
 
+4. Packaging GT.M -
+   Create a tar file from the installed directory

sr_alpha/CVS/Entries

@@ -0,0 +1,22 @@
+/axp.h/1.1/Wed Oct 23 03:49:21 2013//
+/cacheflush.m64/1.1/Wed Oct 23 03:49:21 2013//
+/double2s.c/1.1/Wed Oct 23 03:49:21 2013//
+/emit_code_sp.c/1.1/Wed Oct 23 03:49:21 2013//
+/emit_code_sp.h/1.1/Wed Oct 23 03:49:21 2013//
+/follow.m64/1.1/Wed Oct 23 03:49:21 2013//
+/gtm_dump.c/1.1/Wed Oct 23 03:49:21 2013//
+/inst_flush.m64/1.1/Wed Oct 23 03:49:21 2013//
+/mint2mval.m64/1.1/Wed Oct 23 03:49:21 2013//
+/movq.m64/1.1/Wed Oct 23 03:49:21 2013//
+/mval2bool.m64/1.1/Wed Oct 23 03:49:21 2013//
+/mval2mint.m64/1.1/Wed Oct 23 03:49:21 2013//
+/objlangdefs.h/1.1/Wed Oct 23 03:49:21 2013//
+/op_call.m64/1.1/Wed Oct 23 03:49:21 2013//
+/op_equnul.m64/1.1/Wed Oct 23 03:49:21 2013//
+/op_forlcldo.m64/1.1/Wed Oct 23 03:49:21 2013//
+/op_linestart.m64/1.1/Wed Oct 23 03:49:21 2013//
+/op_pattern.m64/1.1/Wed Oct 23 03:49:21 2013//
+/op_sorts_after.m64/1.1/Wed Oct 23 03:49:21 2013//
+/pseudo_ret.m64/1.1/Wed Oct 23 03:49:21 2013//
+/zbreaksp.h/1.1/Wed Oct 23 03:49:21 2013//
+D

sr_alpha/CVS/Entries.Extra

@@ -0,0 +1,21 @@
+/axp.h////*////
+/cacheflush.m64////*////
+/double2s.c////*////
+/emit_code_sp.c////*////
+/emit_code_sp.h////*////
+/follow.m64////*////
+/gtm_dump.c////*////
+/inst_flush.m64////*////
+/mint2mval.m64////*////
+/movq.m64////*////
+/mval2bool.m64////*////
+/mval2mint.m64////*////
+/objlangdefs.h////*////
+/op_call.m64////*////
+/op_equnul.m64////*////
+/op_forlcldo.m64////*////
+/op_linestart.m64////*////
+/op_pattern.m64////*////
+/op_sorts_after.m64////*////
+/pseudo_ret.m64////*////
+/zbreaksp.h////*////

sr_alpha/CVS/Repository

@@ -0,0 +1 @@
+gtm/sr_alpha

sr_alpha/CVS/Root

@@ -0,0 +1 @@
+:pserver:anonymous@fis-gtm.cvs.sourceforge.net:/cvsroot/fis-gtm

sr_alpha/axp.h

@@ -0,0 +1,133 @@
+/****************************************************************
+ *								*
+ *	Copyright 2001, 2002 Sanchez Computer Associates, Inc.	*
+ *								*
+ *	This source code contains the intellectual property	*
+ *	of its copyright holder(s), and is made available	*
+ *	under a license.  If you do not know the terms of	*
+ *	the license, please stop and do not read further.	*
+ *								*
+ ****************************************************************/
+
+/*	axp.h - AXP machine instruction information.
+ *
+ *	Requires "axp_registers.h" and "axp_gtm_registers.h".
+ *
+ */
+
+
+/*	Machine instruction templates.  */
+
+#define	ALPHA_INS_ADDL		((unsigned)0x10 << ALPHA_SHIFT_OP)
+#define ALPHA_INS_BEQ		((unsigned)0x39 << ALPHA_SHIFT_OP)
+#define ALPHA_INS_BGE		((unsigned)0x3e << ALPHA_SHIFT_OP)
+#define ALPHA_INS_BGT		((unsigned)0x3f << ALPHA_SHIFT_OP)
+#define	ALPHA_INS_BIS		((unsigned)0x11 << ALPHA_SHIFT_OP | 0x20 << ALPHA_SHIFT_FUNC)
+#define ALPHA_INS_BLE		((unsigned)0x3b << ALPHA_SHIFT_OP)
+#define ALPHA_INS_BLT		((unsigned)0x3a << ALPHA_SHIFT_OP)
+#define ALPHA_INS_BLBC		((unsigned)0x38 << ALPHA_SHIFT_OP)
+#define ALPHA_INS_BLBS		((unsigned)0x3c << ALPHA_SHIFT_OP)
+#define ALPHA_INS_BNE		((unsigned)0x3d << ALPHA_SHIFT_OP)
+#define ALPHA_INS_BSR		((unsigned)0x34 << ALPHA_SHIFT_OP)
+#define ALPHA_INS_BR		((unsigned)0x30 << ALPHA_SHIFT_OP)
+#define	ALPHA_INS_JMP		((unsigned)0x1a << ALPHA_SHIFT_OP)
+#define	ALPHA_INS_JSR		((unsigned)0x1a << ALPHA_SHIFT_OP | 1 << ALPHA_SHIFT_BRANCH_FUNC)
+#define	ALPHA_INS_LDA		((unsigned)0x08 << ALPHA_SHIFT_OP)
+#define	ALPHA_INS_LDAH		((unsigned)0x09 << ALPHA_SHIFT_OP)
+#define	ALPHA_INS_LDL		((unsigned)0x28 << ALPHA_SHIFT_OP)
+#define	ALPHA_INS_LDQ		((unsigned)0x29 << ALPHA_SHIFT_OP)
+#define	ALPHA_INS_RET		((unsigned)0x1a << ALPHA_SHIFT_OP | 2 << ALPHA_SHIFT_BRANCH_FUNC)
+#define	ALPHA_INS_STL		((unsigned)0x2c << ALPHA_SHIFT_OP)
+#define	ALPHA_INS_STQ		((unsigned)0x2d << ALPHA_SHIFT_OP)
+#define	ALPHA_INS_SUBL		((unsigned)0x10 << ALPHA_SHIFT_OP | 0x9 << ALPHA_SHIFT_FUNC)
+#define	ALPHA_INS_SUBQ		((unsigned)0x10 << ALPHA_SHIFT_OP | 0x29 << ALPHA_SHIFT_FUNC)
+
+
+/*	Bit offsets to instruction fields.  */
+
+#define ALPHA_SHIFT_OP		26
+#define	ALPHA_SHIFT_BRANCH_FUNC	14
+#define	ALPHA_SHIFT_FUNC	5
+#define	ALPHA_SHIFT_LITERAL	13
+#define ALPHA_SHIFT_RA		21
+#define	ALPHA_SHIFT_RB		16
+#define	ALPHA_SHIFT_RC		0
+#define ALPHA_SHIFT_BRANCH_DISP	0
+#define ALPHA_SHIFT_DISP	0
+
+
+/*	Bit masks for instruction fields.  */
+
+#define	ALPHA_BIT_LITERAL	(1 << 12)
+#define ALPHA_MASK_BRANCH_DISP	0x1fffff
+#define	ALPHA_MASK_BRANCH_FUNC	0xc00000
+#define ALPHA_MASK_DISP		0xffff
+#define	ALPHA_MASK_FUNC		0x7f
+#define	ALPHA_MASK_LITERAL	0xff
+#define	ALPHA_MASK_OP		0x3f
+#define	ALPHA_MASK_REG		0x1f
+
+
+/*	Alternative assembler mnemonics for machine instruction.  */
+
+#define	ALPHA_INS_CLRQ	(ALPHA_INS_BIS \
+				| (ALPHA_REG_ZERO << ALPHA_SHIFT_RA) \
+				| (ALPHA_REG_ZERO << ALPHA_SHIFT_RB))
+#define ALPHA_INS_LPC	(ALPHA_INS_BR \
+				| (GTM_REG_CODEGEN_TEMP << ALPHA_SHIFT_RA))
+#define	ALPHA_INS_MOVE	(ALPHA_INS_BIS \
+				| ALPHA_REG_ZERO << ALPHA_SHIFT_RB)
+#define ALPHA_INS_NOP	(ALPHA_INS_BIS \
+				| (ALPHA_REG_ZERO << ALPHA_SHIFT_RA) \
+				| (ALPHA_REG_ZERO << ALPHA_SHIFT_RB) \
+				| (ALPHA_REG_ZERO << ALPHA_SHIFT_RC))
+
+
+/*	Construction forms.  */
+
+#define ALPHA_BRA(op,ra,disp)	((op) | ((ra) << ALPHA_SHIFT_RA) | (disp)&ALPHA_MASK_BRANCH_DISP)
+#define ALPHA_JMP(op,ra,rb)	((op) | ((ra) << ALPHA_SHIFT_RA) | ((rb) << ALPHA_SHIFT_RB))
+#define ALPHA_LIT(op,ra,lit,rc)	((op) | ((ra) << ALPHA_SHIFT_RA) \
+					| (((lit)&ALPHA_MASK_LITERAL) << ALPHA_SHIFT_LITERAL) \
+					| ALPHA_BIT_LITERAL \
+					| ((rc) << ALPHA_SHIFT_RC))
+#define ALPHA_MEM(op,ra,rb,disp)((op) | ((ra) << ALPHA_SHIFT_RA) | ((rb) << ALPHA_SHIFT_RB) | (disp)&ALPHA_MASK_DISP)
+#define ALPHA_OPR(op,ra,rb,rc)	((op) | ((ra) << ALPHA_SHIFT_RA) | ((rb) << ALPHA_SHIFT_RB) | ((rc) << ALPHA_SHIFT_RC))
+
+#ifdef DEBUG
+#define GET_OPCODE(ains) ((ains >> ALPHA_SHIFT_OP) & ALPHA_MASK_OP)
+#define GET_RA(ains) ((ains >> ALPHA_SHIFT_RA) & ALPHA_MASK_REG)
+#define GET_RB(ains) ((ains >> ALPHA_SHIFT_RB) & ALPHA_MASK_REG)
+#define GET_RC(ains) ((ains >> ALPHA_SHIFT_RC) & ALPHA_MASK_REG)
+#define GET_MEMDISP(ains) ((ains >> ALPHA_SHIFT_DISP) & ALPHA_MASK_DISP)
+#define GET_BRDISP(ains) ((ains >> ALPHA_SHIFT_BRANCH_DISP) & ALPHA_MASK_BRANCH_DISP)
+#define GET_FUNC(ains) ((ains >> ALPHA_SHIFT_FUNC) & ALPHA_MASK_FUNC)
+
+#define ADDL_INST	"addl"
+#define SUBL_INST	"subl"
+#define SUBQ_INST	"subq"
+#define BIS_INST	"bis"
+#define JSR_INST	"jsr"
+#define RET_INST	"ret"
+#define JMP_INST	"jmp"
+#define LDA_INST	"lda"
+#define LDAH_INST	"ldah"
+#define LDL_INST	"ldl"
+#define LDQ_INST	"ldq"
+#define STL_INST	"stl"
+#define STQ_INST	"stq"
+#define BR_INST		"br"
+#define BSR_INST	"bsr"
+#define BLBC_INST	"blbc"
+#define BEQ_INST	"beq"
+#define BLT_INST	"blt"
+#define BLE_INST	"ble"
+#define BLBS_INST	"blbs"
+#define BNE_INST	"bne"
+#define BGE_INST	"bge"
+#define BGT_INST	"bgt"
+#define CONSTANT	"Constant 0x"
+
+/* Space for op_code to be in */
+#define OPSPC		7
+#endif

sr_alpha/cacheflush.m64

@@ -0,0 +1,27 @@
+; ################################################################
+; #                                                              #
+; #      Copyright 2001, 2008 Fidelity Information Services, Inc #
+; #                                                              #
+; #      This source code contains the intellectual property     #
+; #      of its copyright holder(s), and is made available       #
+; #      under a license.  If you do not know the terms of       #
+; #      the license, please stop and do not read further.       #
+; #                                                              #
+; ################################################################
+
+	.title	cacheflush - flush data and instruction caches
+
+;	cacheflush
+;
+;	entry:
+;		a0 (r16)	address of start of region to flush
+;		a1 (r17)	length (in bytes) of region to flush
+;		a2 (r18)	flag indicating which region to flush (not used on AXP)
+
+	$routine	name=cacheflush, entry=cacheflush_ca, kind=null
+
+	imb
+
+	ret	r26
+
+	$end_routine	name=cacheflush

sr_alpha/double2s.c

@@ -0,0 +1,158 @@
+/****************************************************************
+ *								*
+ *	Copyright 2001, 2009 Fidelity Information Services, Inc	*
+ *								*
+ *	This source code contains the intellectual property	*
+ *	of its copyright holder(s), and is made available	*
+ *	under a license.  If you do not know the terms of	*
+ *	the license, please stop and do not read further.	*
+ *								*
+ ****************************************************************/
+
+#include "mdef.h"
+#include "stringpool.h"
+
+#define MAX_NUM_SIZE	64
+
+GBLREF spdesc stringpool;
+
+static	char	pot_index [256] =
+		{
+			-78,  78, -77,  77,  77,  77, -76,  76,  76, -75,  75,  75, -74,  74,  74,  74,
+			-73,  73,  73, -72,  72,  72, -71,  71,  71,  71, -70,  70,  70, -69,  69,  69,
+			-68,  68,  68, -67,  67,  67,  67, -66,  66,  66, -65,  65,  65, -64,  64,  64,
+			 64, -63,  63,  63, -62,  62,  62, -61,  61,  61,  61, -60,  60,  60, -59,  59,
+			 59, -58,  58,  58,  58, -57,  57,  57, -56,  56,  56, -55,  55,  55,  55, -54,
+			 54,  54, -53,  53,  53, -52,  52,  52,  52, -51,  51,  51, -50,  50,  50, -49,
+			 49,  49,  49, -48,  48,  48, -47,  47,  47, -46,  46,  46,  46, -45,  45,  45,
+			-44,  44,  44, -43,  43,  43,  43, -42,  42,  42, -41,  41,  41, -40,  40,  40,
+			 40, -39,  39,  39, -38,  38,  38, -37,  37,  37, -36,  36,  36,  36, -35,  35,
+			 35, -34,  34,  34, -33,  33,  33,  33, -32,  32,  32, -31,  31,  31, -30,  30,
+			 30,  30, -29,  29,  29, -28,  28,  28, -27,  27,  27,  27, -26,  26,  26, -25,
+			 25,  25, -24,  24,  24,  24, -23,  23,  23, -22,  22,  22, -21,  21,  21,  21,
+			-20,  20,  20, -19,  19,  19, -18,  18,  18,  18, -17,  17,  17, -16,  16,  16,
+			-15,  15,  15,  15, -14,  14,  14, -13,  13,  13, -12,  12,  12,  12, -11,  11,
+			 11, -10,  10,  10,  -9,   9,   9,  -8,   8,   8,   8,  -7,   7,   7,  -6,   6,
+			  6,  -5,   5,   5,   5,  -4,   4,   4,  -3,   3,   3,  -2,   2,   2,   2,  -1
+		};
+
+static	double	pot [79] =
+		{
+			1.701411834604692e+38 + 2.83e+22,
+				1e+38,	1e+37,	1e+36,	1e+35,	1e+34,	1e+33,	1e+32,
+			1e+31,	1e+30,	1e+29,	1e+28,	1e+27,	1e+26,	1e+25,	1e+24,
+			1e+23,	1e+22,	1e+21,	1e+20,	1e+19,	1e+18,	1e+17,	1e+16,
+			1e+15,	1e+14,	1e+13,	1e+12,	1e+11,	1e+10,	 1e+9,	 1e+8,
+			 1e+7,	 1e+6,	 1e+5,	 1e+4,	 1e+3,	 1e+2,	 1e+1,	  1.0,
+			 1e-1,	 1e-2,	 1e-3,	 1e-4,	 1e-5,	 1e-6,	 1e-7,	 1e-8,
+			 1e-9,	1e-10,	1e-11,	1e-12,	1e-13,	1e-14,	1e-15,	1e-16,
+			1e-17,	1e-18,	1e-19,	1e-20,	1e-21,	1e-22,	1e-23,	1e-24,
+			1e-25,	1e-26,	1e-27,	1e-28,	1e-29,	1e-30,	1e-31,	1e-32,
+			1e-33,	1e-34,	1e-35,	1e-36,	1e-37,	1e-38,	0
+		};
+
+#define POT_UNITY	39	/* Subscript of pot:  pot[POT_UNITY] == 1.0 */
+
+
+struct	D_float		/* Format of D-floating point datum */
+{
+	unsigned int	     : 7;	/* fraction, bits 0:6 */
+	unsigned int	exp  : 8;	/* exponent, bits 7:14 */
+	unsigned int	sign : 1;	/* sign, bit 15 */
+	unsigned int	     : 16;	/* fraction, bits 16:31 */
+	unsigned int	     : 32;	/* fraction, bits 32:63 */
+};
+
+void	double2s (double *dp, mval *v)
+{
+	double		d = *dp;
+	char		*p, *q;
+	int		i, j, k;
+
+	ENSURE_STP_FREE_SPACE(MAX_NUM_SIZE);
+	assert (stringpool.free >= stringpool.base);
+	v->mvtype = MV_STR;
+	p = v->str.addr
+	  = (char *)stringpool.free;
+
+	if (d == 0.0)
+		*p++ = '0';
+	else
+	{
+		if (d < 0.0)
+		{
+			*p++ = '-';	/* plug in a minus sign */
+			d = -d;		/* but make d positive */
+		}
+
+		i = pot_index[((struct D_float *)dp)->exp];
+		if (i < 0)
+		{
+			i = -i;
+			if (d < pot[i])
+				++i;
+		}
+		i = POT_UNITY + 1 - i;
+
+		/* "Normalize" the number;  i.e. adjust it to be between 0.0 and 1.0 */
+		d *= pot[i + POT_UNITY];
+
+		if (d < 5e-16)
+			/* Call it zero */
+			*p++ = '0';
+		else
+		{
+			/* Round the sixteenth digit */
+			d += 5e-16;
+
+			if (d >= 1.0)
+			{
+				/* Readjust it to be between 0.0 and 1.0 */
+				d /= 10.0;
+				++i;
+			}
+
+			q = p;		/* q will point to the last non-zero byte */
+			j = i;
+
+			if (i <= 0)
+			{
+				*p++ = '.';
+				for (;  i < 0;  ++i)
+					*p++ = '0';
+			}
+
+			for (i = 15;  i > 0;  --i)
+			{
+				/* Multiply the value by ten, put the integer portion
+				   of the result into k (0 <= k <= 9), and replace the
+				   value with the fractional portion of the result	*/
+				k = d *= 10.0;
+				d -= k;
+
+				*p++ = '0' + k;
+
+				if (k > 0)
+					q = p;
+				if (--j == 0)
+				{
+					q = p;
+					*p++ = '.';
+				}
+			}
+
+			if (j > 0)
+				do
+					*p++ = '0';
+				while (--j > 0);
+			else
+				p = q;
+		}
+	}
+
+	v->str.len = p - (char *)stringpool.free;
+	stringpool.free = (unsigned char *)p;
+	assert(stringpool.free <= stringpool.top);
+
+	return;
+}

sr_alpha/emit_code_sp.c

@@ -0,0 +1,278 @@
+/****************************************************************
+ *								*
+ *	Copyright 2001, 2009 Fidelity Information Services, Inc	*
+ *								*
+ *	This source code contains the intellectual property	*
+ *	of its copyright holder(s), and is made available	*
+ *	under a license.  If you do not know the terms of	*
+ *	the license, please stop and do not read further.	*
+ *								*
+ ****************************************************************/
+
+#include "mdef.h"
+
+#include "gtm_string.h"
+
+#include "cgp.h"
+#include "compiler.h"
+#include <rtnhdr.h>
+#include "list_file.h"
+#include <emit_code.h>
+
+GBLREF uint4		code_buf[];	/* Instruction buffer */
+GBLREF int		code_idx;	/* Index into code_buf */
+GBLREF char		cg_phase;	/* Current compiler phase */
+GBLREF int4		curr_addr;
+#ifdef DEBUG
+GBLREF unsigned char    *obpt;		/* output buffer index */
+GBLREF unsigned char    outbuf[];	/* assembly language output buffer */
+static unsigned int	ains;		/* assembler instruction (binary) */
+#endif
+
+
+/* Used by emit_base_offset to extract offset parts */
+int	alpha_adjusted_upper(int offset)
+{
+	int	upper;
+
+	upper = (offset >> 16) & 0xFFFF;
+	if (offset & 0x8000)
+		upper = (upper + 1) & 0xFFFF;
+
+	return upper;
+}
+
+
+void	emit_base_offset(int base, int offset)
+{
+	/* NOTE: emit_base_offset does not advance past its last
+	   generated instruction because that instruction is
+	   incomplete; it contains only a base and offset -- the
+	   rt and opcode field are left empty for use by the caller. */
+	int	upper, low, source;
+
+	switch (cg_phase)
+	{
+#ifdef DEBUG
+		case CGP_ASSEMBLY:
+#endif
+		case CGP_ADDR_OPT:
+		case CGP_APPROX_ADDR:
+		case CGP_MACHINE:
+			assert(base >= 0  &&  base <= 31);
+			source = base;
+			upper = alpha_adjusted_upper(offset);
+
+			if (0 != upper)
+			{
+				code_buf[code_idx++] = ALPHA_INS_LDAH
+					| (GTM_REG_CODEGEN_TEMP << ALPHA_SHIFT_RA)
+					| (source               << ALPHA_SHIFT_RB)
+					| (upper & ALPHA_MASK_DISP) << ALPHA_SHIFT_DISP;
+				source = GTM_REG_CODEGEN_TEMP;
+			}
+			low = offset & 0xFFFF;
+			code_buf[code_idx] = source << ALPHA_SHIFT_RB
+				| (low & ALPHA_MASK_DISP) << ALPHA_SHIFT_DISP;
+			break;
+		default:
+			GTMASSERT;
+	}
+}
+
+
+#ifdef DEBUG
+void fmt_ra()
+{
+	*obpt++ = 'r';
+	obpt = i2asc(obpt, GET_RA(ains));
+}
+void fmt_ra_rb()
+{
+	fmt_ra();
+	*obpt++ = ',';
+	*obpt++;
+	*obpt++ = 'r';
+	obpt = i2asc(obpt, GET_RB(ains));
+}
+void fmt_ra_rb_rc()
+{
+	fmt_ra_rb();
+	*obpt++ = ',';
+	*obpt++;
+	*obpt++ = 'r';
+	obpt = i2asc(obpt, GET_RC(ains));
+}
+void fmt_ra_mem()
+{
+	fmt_ra();
+	*obpt++ = ',';
+	obpt++;
+	*obpt++ = '0';
+	*obpt++ = 'x';
+	obpt += i2hex_nofill(GET_MEMDISP(ains), obpt, 6);
+	*obpt++ = '(';
+	*obpt++ = 'r';
+	obpt = i2asc(obpt, GET_RB(ains));
+	*obpt++ = ')';
+}
+void fmt_ra_brdisp()
+{
+	fmt_ra();
+	*obpt++ = ',';
+	obpt++;
+	*obpt++ = '0';
+	*obpt++ = 'x';
+	obpt += i2hex_nofill(GET_BRDISP(ains) * 4, obpt, 6);
+}
+void 	format_machine_inst(void)
+{
+	int	instindx;
+
+	for (instindx = 0; instindx < code_idx; instindx++)
+	{
+		list_chkpage();
+		obpt = &outbuf[0];
+		memset(obpt, SP, ASM_OUT_BUFF);
+		obpt += 10;
+		i2hex((curr_addr - SIZEOF(rhdtyp)), (uchar_ptr_t)obpt, 8);
+		curr_addr += 4;
+		obpt += 10;
+		i2hex(code_buf[instindx], (uchar_ptr_t)obpt, 8);
+		obpt += 10;
+		ains = code_buf[instindx];
+		switch(GET_OPCODE(ains))
+		{
+			case 0x8:
+				memcpy(obpt, LDA_INST, SIZEOF(LDA_INST) - 1);
+				obpt += OPSPC;
+				fmt_ra_mem();
+				break;
+			case 0x9:
+				memcpy(obpt, LDAH_INST, SIZEOF(LDAH_INST) - 1);
+				obpt += OPSPC;
+				fmt_ra_mem();
+				break;
+			case 0x10:
+			/* Note opcodes 0x10, 0x11, have overlapping functions but none that we generate
+			   so we can combine their disassembly.
+			*/
+			case 0x11:
+				switch(GET_FUNC(ains))
+				{
+					case 0x0:	/* main opcode 0x10 */
+						memcpy(obpt, ADDL_INST, SIZEOF(ADDL_INST) - 1);
+						break;
+					case 0x9:	/* main opcode 0x10 */
+						memcpy(obpt, SUBL_INST, SIZEOF(SUBL_INST) - 1);
+						break;
+					case 0x29:	/* main opcode 0x10 */
+						memcpy(obpt, SUBQ_INST, SIZEOF(SUBQ_INST) - 1);
+						break;
+					case 0x20:	/* main opcode 0x11 */
+						memcpy(obpt, BIS_INST, SIZEOF(BIS_INST) - 1);
+						break;
+					default:
+						GTMASSERT;
+				}
+				obpt += OPSPC;
+				fmt_ra_rb_rc();
+				break;
+			case 0x1a:
+				switch(GET_MEMDISP(ains) & 0x3)
+				{
+					case 0x0:
+						memcpy(obpt, JMP_INST, SIZEOF(JMP_INST) - 1);
+						break;
+					case 0x1:
+						memcpy(obpt, JSR_INST, SIZEOF(JSR_INST) - 1);
+						break;
+					case 0x2:
+						memcpy(obpt, RET_INST, SIZEOF(RET_INST) - 1);
+						break;
+					default:
+						GTMASSERT;
+				}
+				obpt += OPSPC;
+				fmt_ra_rb();
+				break;
+			case 0x28:
+				memcpy(obpt, LDL_INST, SIZEOF(LDL_INST) - 1);
+				obpt += OPSPC;
+				fmt_ra_mem();
+				break;
+			case 0x29:
+				memcpy(obpt, LDQ_INST, SIZEOF(LDQ_INST) - 1);
+				obpt += OPSPC;
+				fmt_ra_mem();
+				break;
+			case 0x2c:
+				memcpy(obpt, STL_INST, SIZEOF(STL_INST) - 1);
+				obpt += OPSPC;
+				fmt_ra_mem();
+				break;
+			case 0x2d:
+				memcpy(obpt, STQ_INST, SIZEOF(STQ_INST) - 1);
+				obpt += OPSPC;
+				fmt_ra_mem();
+				break;
+			case 0x30:
+				memcpy(obpt, BR_INST, SIZEOF(BR_INST) - 1);
+				obpt += OPSPC;
+				fmt_ra_brdisp();
+				break;
+			case 0x34:
+				memcpy(obpt, BSR_INST, SIZEOF(BSR_INST) - 1);
+				obpt += OPSPC;
+				fmt_ra_brdisp();
+				break;
+			case 0x38:
+				memcpy(obpt, BLBC_INST, SIZEOF(BLBC_INST) - 1);
+				obpt += OPSPC;
+				fmt_ra_brdisp();
+				break;
+			case 0x39:
+				memcpy(obpt, BEQ_INST, SIZEOF(BEQ_INST) - 1);
+				obpt += OPSPC;
+				fmt_ra_brdisp();
+				break;
+			case 0x3a:
+				memcpy(obpt, BLT_INST, SIZEOF(BLT_INST) - 1);
+				obpt += OPSPC;
+				fmt_ra_brdisp();
+				break;
+			case 0x3b:
+				memcpy(obpt, BLE_INST, SIZEOF(BLE_INST) - 1);
+				obpt += OPSPC;
+				fmt_ra_brdisp();
+				break;
+			case 0x3c:
+				memcpy(obpt, BLBS_INST, SIZEOF(BLBS_INST) - 1);
+				obpt += OPSPC;
+				fmt_ra_brdisp();
+				break;
+			case 0x3d:
+				memcpy(obpt, BNE_INST, SIZEOF(BNE_INST) - 1);
+				obpt += OPSPC;
+				fmt_ra_brdisp();
+				break;
+			case 0x3e:
+				memcpy(obpt, BGE_INST, SIZEOF(BGE_INST) - 1);
+				obpt += OPSPC;
+				fmt_ra_brdisp();
+				break;
+			case 0x3f:
+				memcpy(obpt, BGT_INST, SIZEOF(BGT_INST) - 1);
+				obpt += OPSPC;
+				fmt_ra_brdisp();
+				break;
+			default: /* Not an instruction but a constant */
+				memcpy(obpt, CONSTANT, SIZEOF(CONSTANT) - 1);
+				obpt += SIZEOF(CONSTANT) - 1;
+				i2hex(ains, obpt, 8);
+				obpt += 8;
+		}
+		emit_eoi();
+	}
+}
+#endif

sr_alpha/emit_code_sp.h

@@ -0,0 +1,206 @@
+/****************************************************************
+ *								*
+ *	Copyright 2003, 2009 Fidelity Information Services, Inc	*
+ *								*
+ *	This source code contains the intellectual property	*
+ *	of its copyright holder(s), and is made available	*
+ *	under a license.  If you do not know the terms of	*
+ *	the license, please stop and do not read further.	*
+ *								*
+ ****************************************************************/
+
+#ifndef EMIT_CODE_SP_INCLUDED
+#define EMIT_CODE_SP_INCLUDED
+
+#include "axp_registers.h"
+#include "axp_gtm_registers.h"
+#include "axp.h"
+
+void	emit_base_offset(int base, int offset);
+int	alpha_adjusted_upper(int offset);
+
+#ifdef DEBUG
+void    format_machine_inst(void);
+void	fmt_ra(void);
+void	fmt_ra_rb(void);
+void	fmt_ra_rb_rc(void);
+void	fmt_ra_mem(void);
+void	fmt_ra_brdisp(void);
+#endif
+
+#define INST_SIZE (int)SIZEOF(uint4)
+#define BRANCH_OFFSET_FROM_IDX(idx_start, idx_end) (idx_end - (idx_start + 1))
+#define LONG_JUMP_OFFSET (0x4ffffffc) /* should be large enough to force the long jump instruction sequence */
+#define MAX_BRANCH_CODEGEN_SIZE 32  /* The length in bytes, of the longest form of branch instruction sequence */
+
+#define MAX_OFFSET 			0x3fff
+#define STACK_ARG_OFFSET(indx)		(8 * (indx)) /* All arguments on Alpha platforms are 8 bytes wide on stack */
+#define MACHINE_FIRST_ARG_REG		ALPHA_REG_A0
+
+/* Register usage in some of the code generation expansions */
+#define CALLS_TINT_TEMP_REG		ALPHA_REG_R1
+#define CLRL_REG			ALPHA_REG_ZERO
+#define CMPL_TEMP_REG			ALPHA_REG_T1
+#define GET_ARG_REG(indx)		(ALPHA_REG_A0 + (indx))
+#define MOVC3_SRC_REG			ALPHA_REG_R0
+#define MOVC3_TRG_REG			ALPHA_REG_R1
+#define MOVL_RETVAL_REG			ALPHA_REG_V0
+#define MOVL_REG_R1			ALPHA_REG_R1
+
+/* Macros to define the opcodes for use in emit_jmp() and emit_tip() args */
+
+#define GENERIC_OPCODE_BEQ		((uint4)ALPHA_INS_BEQ)
+#define GENERIC_OPCODE_BGE		((uint4)ALPHA_INS_BGE)
+#define GENERIC_OPCODE_BGT		((uint4)ALPHA_INS_BGT)
+#define GENERIC_OPCODE_BLE		((uint4)ALPHA_INS_BLE)
+#define GENERIC_OPCODE_BLT		((uint4)ALPHA_INS_BLT)
+#define GENERIC_OPCODE_BNE		((uint4)ALPHA_INS_BNE)
+#define GENERIC_OPCODE_BLBC		((uint4)ALPHA_INS_BLBC)
+#define GENERIC_OPCODE_BLBS		((uint4)ALPHA_INS_BLBS)
+#define GENERIC_OPCODE_BR		((uint4)ALPHA_INS_BR)
+#define GENERIC_OPCODE_LDA		((uint4)ALPHA_INS_LDA)
+#define GENERIC_OPCODE_LOAD		((uint4)ALPHA_INS_LDL)
+#define GENERIC_OPCODE_STORE		((uint4)ALPHA_INS_STL)
+#define GENERIC_OPCODE_NOP		((uint4)ALPHA_INS_NOP)
+
+/* Macro to extract parts of generic opcodes */
+#define GENXCT_LOAD_SRCREG(inst)	((inst >> ALPHA_SHIFT_RB) & ALPHA_MASK_REG)
+
+/* Macros to create specific generated code sequences */
+
+/* Note that the GEN_CLEAR/SET_TRUTH macros are only used on VMS (TRUTH_IN_REG) */
+#define GEN_CLEAR_TRUTH			code_buf[code_idx++] = (ALPHA_INS_STL | ALPHA_REG_ZERO << ALPHA_SHIFT_RA \
+                                                                | GTM_REG_DOLLAR_TRUTH << ALPHA_SHIFT_RB \
+								| 0 << ALPHA_SHIFT_DISP)
+#define GEN_SET_TRUTH                   { \
+                                                code_buf[code_idx++] = (ALPHA_INS_BIS | ALPHA_REG_ZERO << ALPHA_SHIFT_RA \
+                                                                        | 1 << ALPHA_SHIFT_LITERAL | ALPHA_BIT_LITERAL \
+                                                                        | GTM_REG_CODEGEN_TEMP << ALPHA_SHIFT_RC); \
+						code_buf[code_idx++] = (ALPHA_INS_STL | GTM_REG_CODEGEN_TEMP << ALPHA_SHIFT_RA \
+                                                                        | GTM_REG_DOLLAR_TRUTH << ALPHA_SHIFT_RB \
+                                                                        | 0 << ALPHA_SHIFT_DISP); \
+                                        }
+#define GEN_LOAD_ADDR(reg, breg, disp)	code_buf[code_idx++] = (ALPHA_INS_LDA | reg << ALPHA_SHIFT_RA \
+								| breg << ALPHA_SHIFT_RB \
+								| (disp & ALPHA_MASK_DISP) << ALPHA_SHIFT_DISP)
+#define GEN_LOAD_WORD(reg, breg, disp)	code_buf[code_idx++] = (ALPHA_INS_LDL | reg << ALPHA_SHIFT_RA \
+								| breg << ALPHA_SHIFT_RB \
+								| (disp & ALPHA_MASK_DISP) << ALPHA_SHIFT_DISP)
+#define GEN_STORE_WORD(reg, breg, disp)	code_buf[code_idx++] = (ALPHA_INS_STL | reg << ALPHA_SHIFT_RA \
+								| breg << ALPHA_SHIFT_RB \
+								| (disp & ALPHA_MASK_DISP) << ALPHA_SHIFT_DISP)
+#define GEN_LOAD_IMMED(reg, disp)	GEN_LOAD_ADDR(reg, ALPHA_REG_ZERO, disp)
+#define GEN_CLEAR_WORD_EMIT(reg)        emit_trip(*(fst_opr + *inst++), TRUE, ALPHA_INS_STL, reg)
+#define GEN_LOAD_WORD_EMIT(reg)		emit_trip(*(fst_opr + *inst++), TRUE, ALPHA_INS_LDL, reg)
+#define GEN_SUBTRACT_REGS(src1, src2, trgt) \
+                                        code_buf[code_idx++] = (ALPHA_INS_SUBL \
+								| src1 << ALPHA_SHIFT_RA \
+								| src2 << ALPHA_SHIFT_RB \
+								| trgt << ALPHA_SHIFT_RC)
+#define GEN_ADD_IMMED(reg, imval)	code_buf[code_idx++] = (ALPHA_INS_ADDL \
+								| reg << ALPHA_SHIFT_RA \
+								| imval << ALPHA_SHIFT_LITERAL | ALPHA_BIT_LITERAL \
+								| reg << ALPHA_SHIFT_RC)
+#define GEN_JUMP_REG(reg)		code_buf[code_idx++] = (ALPHA_INS_JMP | ALPHA_REG_ZERO << ALPHA_SHIFT_RA \
+								| reg << ALPHA_SHIFT_RB)
+#define GEN_STORE_ARG(reg, offset)	code_buf[code_idx++] = (ALPHA_INS_STQ | reg << ALPHA_SHIFT_RA \
+								| ALPHA_REG_SP << ALPHA_SHIFT_RB \
+								| (offset & ALPHA_MASK_DISP) << ALPHA_SHIFT_DISP)
+#define GEN_PCREL			code_buf[code_idx++] = (ALPHA_INS_LPC)
+#define GEN_MOVE_REG(trg, src)		code_buf[code_idx++] = (ALPHA_INS_MOVE | src << ALPHA_SHIFT_RA | trg << ALPHA_SHIFT_RC)
+
+#if	defined(__vms)
+/*	CALL_INST_SIZE is the byte length of the minimum-length instruction sequence to implement a transfer
+ *	table call.  In the case of OpenVMS AXP, this is the sequence:
+ *
+ *		ldl	r27, xfer(r11)		; get address of procedure descriptor from transfer table
+ *		ldq	r26, 8(r27)		; get code address of procedure from procedure descriptor
+ *		jmp	r26, (r26)		; call it
+ *
+ *	This value is used to determine how to adjust the offset value for a relative call and may not
+ *	be appropriate for the Alpha because VAX relative calls are emulated on the Alpha differently.
+*/
+#  define CALL_INST_SIZE (3 * INST_SIZE)
+#  define GEN_XFER_TBL_CALL(xfer)							\
+   {											\
+	emit_base_offset(GTM_REG_XFER_TABLE, xfer);					\
+	code_buf[code_idx++] |= ALPHA_INS_LDL | ALPHA_REG_PV << ALPHA_SHIFT_RA;		\
+	emit_base_offset(ALPHA_REG_PV, 8);						\
+	code_buf[code_idx++] |= ALPHA_INS_LDQ | ALPHA_REG_RA << ALPHA_SHIFT_RA;		\
+	code_buf[code_idx++] = ALPHA_INS_JSR | ALPHA_REG_RA << ALPHA_SHIFT_RA | ALPHA_REG_RA << ALPHA_SHIFT_RB; \
+   }
+#elif	defined(__osf__)
+/*	CALL_INST_SIZE is the byte length of the minimum-length instruction sequence to implement a transfer
+ *	table call.  In the case of OSF/1 (Digital Unix) AXP, this is the sequence:
+ *
+ *		ldl	r27, offset(r12)	# get address of entry point from transfer table
+ *		jmp	r26, (r27)		# call it
+ *
+ *	This value is used to determine how to adjust the offset value for a relative call and may not
+ *	be appropriate for the Alpha because VAX relative calls are emulated on the Alpha differently.
+*/
+#  define CALL_INST_SIZE (2 * INST_SIZE)
+#  define GEN_XFER_TBL_CALL(xfer)							\
+   {											\
+	emit_base_offset(GTM_REG_XFER_TABLE, xfer);					\
+	code_buf[code_idx++] |= ALPHA_INS_LDL | ALPHA_REG_PV << ALPHA_SHIFT_RA;		\
+	code_buf[code_idx++] = ALPHA_INS_JSR | ALPHA_REG_RA << ALPHA_SHIFT_RA | ALPHA_REG_PV << ALPHA_SHIFT_RB; \
+   }
+#else
+#	error "Unsupported platform"
+#endif
+
+
+/* Macros to return an instruction value. This is typcically used to modify an instruction
+   that is already in the instruction buffer such as the last instruction that was created
+   by emit_pcrel().
+*/
+#define IGEN_COND_BRANCH_REG_OFFSET(opcode, reg, disp) (opcode | ((reg & ALPHA_MASK_REG) << ALPHA_SHIFT_RA) \
+					| ((disp & ALPHA_MASK_DISP) << ALPHA_SHIFT_BRANCH_DISP))
+#define IGEN_UCOND_BRANCH_REG_OFFSET(opcode, reg, disp) IGEN_COND_BRANCH_REG_OFFSET(opcode, reg, disp)
+#define IGEN_LOAD_ADDR_REG(reg)		(ALPHA_INS_LDA | (reg & ALPHA_MASK_REG) << ALPHA_SHIFT_RA)
+#define IGEN_LOAD_WORD_REG(reg)		(ALPHA_INS_LDL | (reg & ALPHA_MASK_REG) << ALPHA_SHIFT_RA)
+#define IGEN_LOAD_NATIVE_REG(reg)	IGEN_LOAD_WORD_REG(reg)
+#define IGEN_COND_BRANCH_OFFSET(disp)	((disp & ALPHA_MASK_BRANCH_DISP) << ALPHA_SHIFT_BRANCH_DISP)
+#define IGEN_UCOND_BRANCH_OFFSET(disp)	IGEN_COND_BRANCH_OFFSET(disp)
+#define IGEN_LOAD_LINKAGE(reg)		(ALPHA_INS_LDQ | (reg & ALPHA_MASK_REG) << ALPHA_SHIFT_RA)
+#define IGEN_GENERIC_REG(opcode, reg)	(opcode | ((reg & ALPHA_MASK_REG) << ALPHA_SHIFT_RA))
+
+/* Some macros that are used in certain routines in emit_code.c. The names of these
+   macros start with the routine name they are used in.
+*/
+
+/* Branch has origin of +1 instructions. However, if the branch was nullified in an earlier shrink_trips,
+ * the origin is the current instruction itself */
+#define EMIT_JMP_ADJUST_BRANCH_OFFSET	branch_offset = ((branch_offset != 0) ? branch_offset - 1 : 0)
+/* Can jump be done within range of immediate operand */
+#define EMIT_JMP_SHORT_CODE_CHECK	(branch_offset >= (-(ALPHA_MASK_BRANCH_DISP/2) - 1)	\
+					 && branch_offset <= (ALPHA_MASK_BRANCH_DISP/2))
+/* Emit the short jump */
+#define EMIT_JMP_SHORT_CODE_GEN									\
+{												\
+	code_buf[code_idx++] = (branchop | (reg << ALPHA_SHIFT_RA)				\
+		| ((branch_offset & ALPHA_MASK_BRANCH_DISP) << ALPHA_SHIFT_BRANCH_DISP));	\
+	branch_offset--;									\
+}
+/* Is this a conditional branch? */
+#define EMIT_JMP_OPPOSITE_BR_CHECK	(branchop != ALPHA_INS_BR && (branchop != ALPHA_INS_BEQ || reg != ALPHA_REG_ZERO))
+#define EMIT_JMP_GEN_COMPARE		/* No compare necessary */
+#define EMIT_JMP_LONG_CODE_CHECK	FALSE
+/* Is the offset field in this instruction zero? */
+#define EMIT_JMP_ZERO_DISP_COND		(0 == ((code_buf[code_idx] >> ALPHA_SHIFT_DISP) & ALPHA_MASK_DISP))
+/* Emit code to load a given numeric literal */
+#define EMIT_TRIP_ILIT_GEN		{	/* Emit liternal number */						\
+	                                        emit_base_offset(ALPHA_REG_ZERO, immediate);				\
+						code_buf[code_idx++] |= (ALPHA_INS_LDA |				\
+									 (trg_reg & ALPHA_MASK_REG) << ALPHA_SHIFT_RA); \
+                                        }
+/*
+ * GT.M on AIX and SPARC is 64bit
+ * By default the loads/stores use ldd/std(load double),
+ * but if the value being dealt with is a word,the
+ * opcode in generic_inst is changed to ldw/stw
+ */
+#define REVERT_GENERICINST_TO_WORD(inst)
+
+#endif

sr_alpha/follow.m64

@@ -0,0 +1,32 @@
+; ################################################################
+; #                                                              #
+; #      Copyright 2001, 2008 Fidelity Information Services, Inc #
+; #                                                              #
+; #      This source code contains the intellectual property     #
+; #      of its copyright holder(s), and is made available       #
+; #      under a license.  If you do not know the terms of       #
+; #      the license, please stop and do not read further.       #
+; #                                                              #
+; ################################################################
+
+	.title	FOLLOW	"Allows run-time modules to call OP_FOLLOW"
+
+;	FOLLOW simply passes its two arguments, which are pointers to
+;	mval's, to OP_FOLLOW, which expects them in registers r0 and r1.
+;	OP_FOLLOW returns 1, 0, or -1;  FOLLOW returns a boolean result:
+;	1 (true) if OP_FOLLOW returned 1, otherwise 0 (false).
+
+	$routine FOLLOW, entry=FOLLOW_CA, kind=stack
+	.base	r27, $ls
+
+	sextl	r16, r0
+	sextl	r17, r1
+	$call	OP_FOLLOW, set_arg_info=false
+	sextl	r0, r0
+	cmovlt	r0, 0, r0
+
+	$return
+
+	$end_routine
+
+	.end

sr_alpha/gtm_dump.c

@@ -9,9 +9,9 @@
  *								*
  ****************************************************************/
 
-#ifndef MU_FILE_SIZE_INCLUDED
+/*** STUB FILE ***/
-#define MU_FILE_SIZE_INCLUDED
 
-unsigned int mu_file_size(file_control *fc);
+#include "mdef.h"
+#include "error.h"
 
-#endif /* MU_FILE_SIZE_INCLUDED */
+void gtm_dump(void) {};

sr_alpha/inst_flush.m64

@@ -0,0 +1,24 @@
+; ################################################################
+; #                                                              #
+; #      Copyright 2001, 2008 Fidelity Information Services, Inc #
+; #                                                              #
+; #      This source code contains the intellectual property     #
+; #      of its copyright holder(s), and is made available       #
+; #      under a license.  If you do not know the terms of       #
+; #      the license, please stop and do not read further.       #
+; #                                                              #
+; ################################################################
+
+	.title	inst_flush	flush instruction cache
+
+;	inst_flush is a C-callable routine that makes the instruction cache coherent with memory.
+
+	$routine	name=inst_flush,entry=inst_flush_ca,kind=null
+
+	imb
+
+	ret	r26
+
+	$end_routine	name=inst_flush
+
+	.end

sr_alpha/mint2mval.m64

@@ -0,0 +1,51 @@
+	.title	mint2mval "Convert integer to mval"
+
+; ###############################################################
+; #								#
+; #	Copyright 2001, 2004 Sanchez Computer Associates, Inc.	#
+; #								#
+; #	This source code contains the intellectual property	#
+; #	of its copyright holder(s), and is made available	#
+; #	under a license.  If you do not know the terms of	#
+; #	the license, please stop and do not read further.	#
+; #								#
+; ###############################################################
+
+;	On input, r1 = integer value, r0 -> mval
+
+	mval$def
+
+	$linkage_section
+
+int_hi_val:
+	.quad	INT_HI
+
+	$routine MINT2MVAL, entry=MINT2MVAL_CA, kind=null
+	lda	sp, -24(sp)
+	stq	r26, (sp)
+	stq	r13, 8(sp)
+	mov	r27, r13
+	.base	r13, $ls
+
+	ldq	r22, int_hi_val
+	cmplt	r1, r22, r28
+	beq	r28, 11$		; int >= INT_HI
+	negq	r22, r22
+	cmple	r1, r22, r28
+	bne	r28, 11$		; int <= -INT_HI
+
+	mv_i2mval r1, r0
+
+12$:	ldq	r26, (sp)
+	ldq	r13, 8(sp)
+	lda	sp, 24(sp)
+	ret	r26
+
+11$:	mov	r0, r16
+	mov	r1, r17
+	$call I2MVAL, args=<r16, r17>, set_arg_info=false, nonstandard=true
+	br	12$
+
+	$end_routine
+
+	.end

sr_alpha/movq.m64

@@ -0,0 +1,21 @@
+; ################################################################
+; #                                                              #
+; #      Copyright 2001, 2008 Fidelity Information Services, Inc #
+; #                                                              #
+; #      This source code contains the intellectual property     #
+; #      of its copyright holder(s), and is made available       #
+; #      under a license.  If you do not know the terms of       #
+; #      the license, please stop and do not read further.       #
+; #                                                              #
+; ################################################################
+
+	.title	movq	move quadword
+
+	$routine	name=movq,entry=movq_ca,kind=null
+
+	ldq	r28, (r16)
+	stq	r28, (r17)
+
+	ret	r26
+
+	$end_routine	name=movq

sr_alpha/mval2bool.m64

@@ -0,0 +1,39 @@
+; ################################################################
+; #                                                              #
+; #      Copyright 2000, 2008 Fidelity Information Services, Inc #
+; #                                                              #
+; #      This source code contains the intellectual property     #
+; #      of its copyright holder(s), and is made available       #
+; #      under a license.  If you do not know the terms of       #
+; #      the license, please stop and do not read further.       #
+; #                                                              #
+; ################################################################
+
+	.title	mval2bool "Sets condition code from mval"
+
+;	On entry, r1 -> mval.
+;	On exit, r24 = numeric value of mval
+
+	mval$def
+
+	$routine MVAL2BOOL, entry=MVAL2BOOL_CA, kind=null
+	lda	sp, -24(sp)
+	stq	r26, (sp)
+	stq	r13, 8(sp)
+	mov	r27, r13
+	.base	r13, $ls
+
+	mv_force_defined r1
+	stq	r1, 16(sp)
+	mv_force_num (r1)
+	ldq	r1, 16(sp)
+	ldl	r24, mval$l_m1(r1)
+
+	ldq	r26, (sp)
+	ldq	r13, 8(sp)
+	lda	sp, 24(sp)
+	ret	r26
+
+	$end_routine
+
+	.end

sr_alpha/mval2mint.m64

@@ -0,0 +1,39 @@
+; ################################################################
+; #                                                              #
+; #      Copyright 2000, 2008 Fidelity Information Services, Inc #
+; #                                                              #
+; #      This source code contains the intellectual property     #
+; #      of its copyright holder(s), and is made available       #
+; #      under a license.  If you do not know the terms of       #
+; #      the license, please stop and do not read further.       #
+; #                                                              #
+; ################################################################
+
+	.title	mval2mint "Converts an mval to integer"
+
+;	On entry, r1 -> mval
+;	On exit, r0 = integer value
+
+	mval$def
+
+	$routine MVAL2MINT, entry=MVAL2MINT_CA, kind=null
+	lda	sp, -24(sp)
+	stq	r26, (sp)
+	stq	r13, 8(sp)
+	mov	r27, r13
+	.base	r13, $ls
+
+	mv_force_defined r1
+	stq	r1, 16(sp)
+	mv_force_num (r1)
+	ldq	r16, 16(sp)
+	$call	MVAL2I, args=<r16>, set_arg_info=false, nonstandard=true
+
+	ldq	r26, (sp)
+	ldq	r13, 8(sp)
+	lda	sp, 24(sp)
+	ret	r26
+
+	$end_routine
+
+	.end

sr_alpha/objlangdefs.h

@@ -0,0 +1,457 @@
+/****************************************************************
+ *								*
+ *	Copyright 2001 Sanchez Computer Associates, Inc.	*
+ *								*
+ *	This source code contains the intellectual property	*
+ *	of its copyright holder(s), and is made available	*
+ *	under a license.  If you do not know the terms of	*
+ *	the license, please stop and do not read further.	*
+ *								*
+ ****************************************************************/
+
+/* Object record types: */
+#define	EOBJ$C_EMH		8
+#define	EOBJ$C_EEOM		9
+#define	EOBJ$C_EGSD		10
+#define	EOBJ$C_ETIR		11
+#define	EOBJ$C_EDBG		12
+#define	EOBJ$C_ETBT		13
+#define	EOBJ$C_MAXRECTYP	13
+
+/* Byte offsets into object record and related constants: */
+#define	EOBJ$K_SUBTYP		4
+#define	EOBJ$C_SUBTYP		4
+#define	EOBJ$C_MAXRECSIZ	8192
+#define	EOBJ$C_STRLVL		2
+#define	EOBJ$C_SYMSIZ		31
+#define	EOBJ$C_STOREPLIM	-1
+#define	EOBJ$C_PSCALILIM	16
+#define	EOBJ$S_EOBJRECDEF	10
+#define	EOBJ$W_RECTYP		0
+#define	EOBJ$W_SIZE		2
+#define	EOBJ$W_SUBTYP		4
+#define	EOBJ$B_MHD_STRLV	6
+#define	EOBJ$B_MHD_HOLD		7
+#define	EOBJ$W_MHD_RECSZ	8
+#define	EOBJ$T_MHD_NAME		10
+
+/* Object header record (EOBJ$C_EMH) subtypes: */
+#define	EMH$C_MHD		0
+#define	EMH$C_LNM		1
+#define	EMH$C_SRC		2
+#define	EMH$C_TTL		3
+#define	EMH$C_CPR		4
+#define	EMH$C_MTC		5
+#define	EMH$C_GTX		6
+#define	EMH$C_MAXHDRTYP		6
+
+/* Byte offsets of fields in object header record (EOBJ$C_EMH): */
+#define	EMH$S_EMHDEF		52
+#define	EMH$W_RECTYP		0
+#define	EMH$W_SIZE		2
+#define	EMH$W_HDRTYP		4
+#define	EMH$B_STRLVL		6
+#define	EMH$B_TEMP		7
+#define	EMH$L_ARCH1		8
+#define	EMH$L_ARCH2		12
+#define	EMH$L_RECSIZ		16
+#define	EMH$B_NAMLNG		20
+#define	EMH$S_NAME		31
+#define	EMH$T_NAME		21
+
+#define	EEOM$C_SUCCESS		0
+#define	EEOM$C_WARNING		1
+#define	EEOM$C_ERROR		2
+#define	EEOM$C_ABORT		3
+#define	EEOM$K_EOMMIN		10
+#define	EEOM$C_EOMMIN		10
+#define	EEOM$K_EOMMX1		10
+#define	EEOM$C_EOMMX1		10
+#define	EEOM$M_WKTFR		0X1
+#define	EEOM$K_EOMMAX		24
+#define	EEOM$C_EOMMAX		24
+#define	EEOM$S_EEOMDEF		24
+#define	EEOM$W_RECTYP		0
+#define	EEOM$W_SIZE		2
+#define	EEOM$L_TOTAL_LPS	4
+#define	EEOM$W_COMCOD		8
+#define	EEOM$B_TFRFLG		10
+#define	EEOM$V_WKTFR		0
+#define	EEOM$B_TEMP		11
+#define	EEOM$L_PSINDX		12
+#define	EEOM$S_TFRADR		8
+#define	EEOM$Q_TFRADR		16
+#define	EEOM$L_TFRADR		16
+
+
+#define	EGSD$K_ENTRIES		2
+#define	EGSD$C_ENTRIES		2
+
+#define	EGSD$C_PSC		0
+#define	EGSD$C_SYM		1
+#define	EGSD$C_IDC		2
+#define	EGSD$C_ENV		3
+#define	EGSD$C_LSY		4
+#define	EGSD$C_SPSC		5
+#define	EGSD$C_SYMV		6
+#define	EGSD$C_SYMM		7
+#define	EGSD$C_SYMG		8
+#define	EGSD$C_MAXRECTYP	8
+
+#define	EGSD$S_EGSDEF		12
+#define	EGSD$W_RECTYP		0
+#define	EGSD$W_RECSIZ		2
+#define	EGSD$L_ALIGNLW		4
+#define	EGSD$W_GSDTYP		8
+#define	EGSD$W_GSDSIZ		10
+
+#define	EGPS$M_PIC		0X1
+#define	EGPS$M_LIB		0X2
+#define	EGPS$M_OVR		0X4
+#define	EGPS$M_REL		0X8
+#define	EGPS$M_GBL		0X10
+#define	EGPS$M_SHR		0X20
+#define	EGPS$M_EXE		0X40
+#define	EGPS$M_RD		0X80
+#define	EGPS$M_WRT		0X100
+#define	EGPS$M_VEC		0X200
+#define	EGPS$M_NOMOD		0X400
+#define	EGPS$M_COM		0X800
+#define	EGPS$K_NAME		12
+#define	EGPS$C_NAME		12
+#define	EGPS$S_EGPSDEF		44
+#define	EGPS$W_GSDTYP		0
+#define	EGPS$T_START		0
+#define	EGPS$W_SIZE		2
+#define	EGPS$B_ALIGN		4
+#define	EGPS$B_TEMP		5
+#define	EGPS$W_FLAGS		6
+#define	EGPS$V_PIC		0
+#define	EGPS$V_LIB		1
+#define	EGPS$V_OVR		2
+#define	EGPS$V_REL		3
+#define	EGPS$V_GBL		4
+#define	EGPS$V_SHR		5
+#define	EGPS$V_EXE		6
+#define	EGPS$V_RD		7
+#define	EGPS$V_WRT		8
+#define	EGPS$V_VEC		9
+#define	EGPS$V_NOMOD		10
+#define	EGPS$V_COM		11
+#define	EGPS$L_ALLOC		8
+#define	EGPS$B_NAMLNG		12
+#define	EGPS$S_NAME		31
+#define	EGPS$T_NAME		13
+
+#define	ESGPS$M_PIC		0X1
+#define	ESGPS$M_LIB		0X2
+#define	ESGPS$M_OVR		0X4
+#define	ESGPS$M_REL		0X8
+#define	ESGPS$M_GBL		0X10
+#define	ESGPS$M_SHR		0X20
+#define	ESGPS$M_EXE		0X40
+#define	ESGPS$M_RD		0X80
+#define	ESGPS$M_WRT		0X100
+#define	ESGPS$M_VEC		0X200
+#define	ESGPS$M_NOMOD		0X400
+#define	ESGPS$M_COM		0X800
+#define	ESGPS$K_NAME		25
+#define	ESGPS$C_NAME		25
+#define	ESGPS$S_ESGPSDEF	56
+#define	ESGPS$W_GSDTYP		0
+#define	ESGPS$T_START		0
+#define	ESGPS$W_SIZE		2
+#define	ESGPS$B_ALIGN		4
+#define	ESGPS$B_TEMP		5
+#define	ESGPS$W_FLAGS		6
+#define	ESGPS$V_PIC		0
+#define	ESGPS$V_LIB		1
+#define	ESGPS$V_OVR		2
+#define	ESGPS$V_REL		3
+#define	ESGPS$V_GBL		4
+#define	ESGPS$V_SHR		5
+#define	ESGPS$V_EXE		6
+#define	ESGPS$V_RD		7
+#define	ESGPS$V_WRT		8
+#define	ESGPS$V_VEC		9
+#define	ESGPS$V_NOMOD		10
+#define	ESGPS$V_COM		11
+#define	ESGPS$L_ALLOC		8
+#define	ESGPS$L_BASE		12
+#define	ESGPS$S_VALUE		8
+#define	ESGPS$Q_VALUE		16
+#define	ESGPS$L_VALUE		16
+#define	ESGPS$B_NAMLNG		24
+#define	ESGPS$S_NAME		31
+#define	ESGPS$T_NAME		25
+
+#define	EGSY$M_WEAK		0X1
+#define	EGSY$M_DEF		0X2
+#define	EGSY$M_UNI		0X4
+#define	EGSY$M_REL		0X8
+#define	EGSY$M_COMM		0X10
+#define	EGSY$M_VECEP		0X20
+#define	EGSY$M_NORM		0X40
+#define	EGSY$S_EGSYDEF		8
+#define	EGSY$W_GSDTYP		0
+#define	EGSY$T_START		0
+#define	EGSY$W_SIZE		2
+#define	EGSY$B_DATYP		4
+#define	EGSY$B_TEMP		5
+#define	EGSY$W_FLAGS		6
+#define	EGSY$V_WEAK		0
+#define	EGSY$V_DEF		1
+#define	EGSY$V_UNI		2
+#define	EGSY$V_REL		3
+#define	EGSY$V_COMM		4
+#define	EGSY$V_VECEP		5
+#define	EGSY$V_NORM		6
+
+#define	EGST$K_NAME		37
+#define	EGST$C_NAME		37
+#define	EGST$S_EGSTDEF		68
+#define	EGST$W_GSDTYP		0
+#define	EGST$T_START		0
+#define	EGST$W_SIZE		2
+#define	EGST$B_DATYP		4
+#define	EGST$B_TEMP		5
+#define	EGST$W_FLAGS		6
+#define	EGST$S_VALUE		8
+#define	EGST$Q_VALUE		8
+#define	EGST$L_VALUE		8
+#define	EGST$S_LP_1		8
+#define	EGST$Q_LP_1		16
+#define	EGST$L_LP_1		16
+#define	EGST$S_LP_2		8
+#define	EGST$Q_LP_2		24
+#define	EGST$L_LP_2		24
+#define	EGST$L_PSINDX		32
+#define	EGST$B_NAMLNG		36
+#define	EGST$S_NAME		31
+#define	EGST$T_NAME		37
+
+#define	ESDF$K_NAME		33
+#define	ESDF$C_NAME		33
+#define	ESDF$S_ESDFDEF		64
+#define	ESDF$W_GSDTYP		0
+#define	ESDF$T_START		0
+#define	ESDF$W_SIZE		2
+#define	ESDF$B_DATYP		4
+#define	ESDF$B_TEMP		5
+#define	ESDF$W_FLAGS		6
+#define	ESDF$S_VALUE		8
+#define	ESDF$Q_VALUE		8
+#define	ESDF$L_VALUE		8
+#define	ESDF$S_CODE_ADDRESS	8
+#define	ESDF$Q_CODE_ADDRESS	16
+#define	ESDF$L_CODE_ADDRESS	16
+#define	ESDF$L_CA_PSINDX	24
+#define	ESDF$L_PSINDX		28
+#define	ESDF$B_NAMLNG		32
+#define	ESDF$S_NAME		31
+#define	ESDF$T_NAME		33
+
+#define	ESDFV$K_NAME		25
+#define	ESDFV$C_NAME		25
+#define	ESDFV$S_ESDFVDEF	56
+#define	ESDFV$W_GSDTYP		0
+#define	ESDFV$T_START		0
+#define	ESDFV$W_SIZE		2
+#define	ESDFV$B_DATYP		4
+#define	ESDFV$B_TEMP		5
+#define	ESDFV$W_FLAGS		6
+#define	ESDFV$S_VALUE		8
+#define	ESDFV$Q_VALUE		8
+#define	ESDFV$L_VALUE		8
+#define	ESDFV$L_PSINDX		16
+#define	ESDFV$L_VECTOR		20
+#define	ESDFV$B_NAMLNG		24
+#define	ESDFV$S_NAME		31
+#define	ESDFV$T_NAME		25
+#define	ESDFM$K_NAME		25
+#define	ESDFM$C_NAME		25
+#define	ESDFM$S_ESDFMDEF	56
+#define	ESDFM$W_GSDTYP		0
+#define	ESDFM$T_START		0
+#define	ESDFM$W_SIZE		2
+#define	ESDFM$B_DATYP		4
+#define	ESDFM$B_TEMP		5
+#define	ESDFM$W_FLAGS		6
+#define	ESDFM$S_VALUE		8
+#define	ESDFM$Q_VALUE		8
+#define	ESDFM$L_VALUE		8
+#define	ESDFM$L_PSINDX		16
+#define	ESDFM$L_VERSION_MASK	20
+#define	ESDFM$B_NAMLNG		24
+#define	ESDFM$S_NAME		31
+#define	ESDFM$T_NAME		25
+#define	ESRF$K_NAME		9
+#define	ESRF$C_NAME		9
+#define	ESRF$S_ESRFDEF		40
+#define	ESRF$W_GSDTYP		0
+#define	ESRF$T_START		0
+#define	ESRF$W_SIZE		2
+#define	ESRF$B_DATYP		4
+#define	ESRF$B_TEMP		5
+#define	ESRF$W_FLAGS		6
+#define	ESRF$B_NAMLNG		8
+#define	ESRF$S_NAME		31
+#define	ESRF$T_NAME		9
+#define	EIDC$C_LEQ		0
+#define	EIDC$C_EQUAL		1
+#define	EIDC$S_EIDCDEF		7
+#define	EIDC$W_GSDTYP		0
+#define	EIDC$W_SIZE		2
+#define	EIDC$B_NAMLNG		4
+#define	EIDC$T_NAME		5
+#define	EIDC$W_FLAGS		5
+#define	EIDC$V_BINIDENT		0
+#define	EIDC$S_IDMATCH		2
+#define	EIDC$V_IDMATCH		1
+#define	EIDC$S_ERRSEV		3
+#define	EIDC$V_ERRSEV		3
+
+#define	EENV$M_DEF		0X1
+#define	EENV$M_NESTED		0X2
+#define	EENV$S_EENVDEF		40
+#define	EENV$W_GSDTYP		0
+#define	EENV$W_SIZE		2
+#define	EENV$W_FLAGS		4
+#define	EENV$V_DEF		0
+#define	EENV$V_NESTED		1
+#define	EENV$W_ENVINDX		6
+#define	EENV$B_NAMLNG		8
+#define	EENV$S_NAME		31
+#define	EENV$T_NAME		9
+
+#define	ELSY$M_WEAK		0X1
+#define	ELSY$M_DEF		0X2
+#define	ELSY$M_UNI		0X4
+#define	ELSY$M_REL		0X8
+#define	ELSY$S_ELSYDEF		14
+#define	ELSY$W_GSDTYP		0
+#define	ELSY$T_START		0
+#define	ELSY$W_SIZE		2
+#define	ELSY$B_DATYP		4
+#define	ELSY$B_TEMP1		5
+#define	ELSY$W_FLAGS		6
+#define	ELSY$V_WEAK		0
+#define	ELSY$V_DEF		1
+#define	ELSY$V_UNI		2
+#define	ELSY$V_REL		3
+#define	ELSY$L_PSINDX		8
+#define	ELSY$W_ENVINDX		12
+
+#define	ELSRF$K_NAME		17
+#define	ELSRF$C_NAME		17
+#define	ELSRF$S_ELSRFDEF	48
+#define	ELSRF$W_GSDTYP		0
+#define	ELSRF$T_START		0
+#define	ELSRF$W_SIZE		2
+#define	ELSRF$B_DATYP		4
+#define	ELSRF$B_TEMP1		5
+#define	ELSRF$W_FLAGS		6
+#define	ELSRF$L_PSINDX		8
+#define	ELSRF$W_ENVINDX		12
+#define	ELSRF$W_TEMP2		14
+#define	ELSRF$B_NAMLNG		16
+#define	ELSRF$S_NAME		31
+#define	ELSRF$T_NAME		17
+
+#define	ELSDF$K_NAME		25
+#define	ELSDF$C_NAME		25
+#define	ELSDF$S_ELSDFDEF	56
+#define	ELSDF$W_GSDTYP		0
+#define	ELSDF$T_START		0
+#define	ELSDF$W_SIZE		2
+#define	ELSDF$B_DATYP		4
+#define	ELSDF$B_TEMP1		5
+#define	ELSDF$W_FLAGS		6
+#define	ELSDF$S_VALUE		8
+#define	ELSDF$Q_VALUE		8
+#define	ELSDF$L_VALUE		8
+#define	ELSDF$L_PSINDX		16
+#define	ELSDF$W_ENVINDX		20
+#define	ELSDF$W_TEMP2		22
+#define	ELSDF$B_NAMLNG		24
+#define	ELSDF$S_NAME		31
+#define	ELSDF$T_NAME		25
+
+/* ETIR command types: */
+/* ETIR stack commands: */
+#define	ETIR$C_MINSTACOD	0
+#define	ETIR$C_STA_GBL		0
+#define	ETIR$C_STA_LW		1
+#define	ETIR$C_STA_QW		2
+#define	ETIR$C_STA_PQ		3
+#define	ETIR$C_STA_LI		4
+#define	ETIR$C_STA_MOD		5
+#define	ETIR$C_STA_CKARG	6
+#define	ETIR$C_MAXSTACOD	6
+
+#define	ETIR$C_MINSTOCOD	50
+#define	ETIR$C_STO_B		50
+#define	ETIR$C_STO_W		51
+#define	ETIR$C_STO_LW		52
+#define	ETIR$C_STO_QW		53
+#define	ETIR$C_STO_IMMR		54
+#define	ETIR$C_STO_GBL		55
+#define	ETIR$C_STO_CA		56
+#define	ETIR$C_STO_RB		57
+#define	ETIR$C_STO_AB		58
+#define	ETIR$C_STO_OFF		59
+#define	ETIR$C_STO_IMM		61
+#define	ETIR$C_STO_GBL_LW	62
+#define	ETIR$C_STO_HINT_GBL	64
+#define	ETIR$C_STO_HINT_PS	65
+#define	ETIR$C_MAXSTOCOD	65
+
+#define	ETIR$C_MINOPRCOD	100
+#define	ETIR$C_OPR_NOP		100
+#define	ETIR$C_OPR_ADD		101
+#define	ETIR$C_OPR_SUB		102
+#define	ETIR$C_OPR_MUL		103
+#define	ETIR$C_OPR_DIV		104
+#define	ETIR$C_OPR_AND		105
+#define	ETIR$C_OPR_IOR		106
+#define	ETIR$C_OPR_EOR		107
+#define	ETIR$C_OPR_NEG		108
+#define	ETIR$C_OPR_COM		109
+#define	ETIR$C_OPR_INSV		110
+#define	ETIR$C_OPR_ASH		111
+#define	ETIR$C_OPR_USH		112
+#define	ETIR$C_OPR_ROT		113
+#define	ETIR$C_OPR_SEL		114
+#define	ETIR$C_OPR_REDEF	115
+#define	ETIR$C_OPR_DFLIT	116
+#define	ETIR$C_MAXOPRCOD	116
+
+#define	ETIR$C_MINCTLCOD	150
+#define	ETIR$C_CTL_SETRB	150
+#define	ETIR$C_CTL_AUGRB	151
+#define	ETIR$C_CTL_DFLOC	152
+#define	ETIR$C_CTL_STLOC	153
+#define	ETIR$C_CTL_STKDL	154
+#define	ETIR$C_MAXCTLCOD	154
+
+#define	ETIR$C_MINSTCCOD	200
+#define	ETIR$C_STC_LP		200
+#define	ETIR$C_STC_LP_PSB	201
+#define	ETIR$C_STC_GBL		202
+#define	ETIR$C_STC_GCA		203
+#define	ETIR$C_STC_PS		204
+#define	ETIR$C_STC_NOP_GBL	205
+#define	ETIR$C_STC_NOP_PS	206
+#define	ETIR$C_STC_BSR_GBL	207
+#define	ETIR$C_STC_BSR_PS	208
+#define	ETIR$C_STC_LDA_GBL	209
+#define	ETIR$C_STC_LDA_PS	210
+#define	ETIR$C_STC_BOH_GBL	211
+#define	ETIR$C_STC_BOH_PS	212
+#define	ETIR$C_STC_NBH_GBL	213
+#define	ETIR$C_STC_NBH_PS	214
+#define	ETIR$C_MAXSTCCOD	214
+
+#define	ETIR$S_ETIRDEF		4
+#define	ETIR$W_RECTYP		0
+#define	ETIR$W_SIZE		2

sr_alpha/op_call.m64

@@ -0,0 +1,51 @@
+	.title	OP_CALL
+; ###############################################################
+; #								#
+; #	Copyright 2001, 2003 Sanchez Computer Associates, Inc.	#
+; #								#
+; #	This source code contains the intellectual property	#
+; #	of its copyright holder(s), and is made available	#
+; #	under a license.  If you do not know the terms of	#
+; # 	the license, please stop and do not read further.	#
+; #								#
+; ###############################################################
+
+	G_MSF
+
+
+	$linkage_section
+
+a_frame_pointer:
+	.address frame_pointer
+
+
+	$code_section
+
+	$routine OP_CALLB, entry=OP_CALL_CA, aliases=<OP_CALLW, OP_CALLL>, kind=null
+
+	lda	sp, -16(sp)
+	stq	r13, 8(sp)
+	stq	r26, (sp)
+	mov	r27, r13
+	.base	r13, $ls
+
+	ldq	r1, a_frame_pointer
+	ldl	r1, (r1)
+
+;	Bump the return PC past the branch sequence following the jsr that got us here:
+	addl	r26, r16, r26		; length of branch sequence
+	stl	r26, msf$mpc_off(r1)	; and store it in the Mumps stack frame
+
+	$call	COPY_STACK_FRAME, set_arg_info=false, nonstandard=true
+
+	ldq	r12, a_frame_pointer
+	ldl	r12, (r12)
+
+	ldq	r26, (sp)
+	ldq	r13, 8(sp)
+	lda	sp, 16(sp)
+	ret	r26
+
+	$end_routine
+
+	.end

sr_alpha/op_equnul.m64

@@ -0,0 +1,61 @@
+; ################################################################
+; #                                                              #
+; #      Copyright 2001, 2008 Fidelity Information Services, Inc #
+; #                                                              #
+; #      This source code contains the intellectual property     #
+; #      of its copyright holder(s), and is made available       #
+; #      under a license.  If you do not know the terms of       #
+; #      the license, please stop and do not read further.       #
+; #                                                              #
+; ################################################################
+
+	.title	OP_EQUNUL "Compare mval to null string"
+
+	mval$def
+
+
+	$linkage_section
+
+a_undef_inhibit:
+	.address undef_inhibit
+
+
+	$code_section
+
+	$routine OP_EQUNUL, entry=OP_EQUNUL_CA, kind=null
+	.base	r27, $ls
+
+	mv_if_notdefined (r0), 30$
+
+	mv_if_notstring (r0), 20$
+	ldl	r28, mval$l_strlen(r0)
+	bne	r28, 20$
+
+;	Mval is a null string
+10$:	mov	1, r24
+	ret	r26
+
+;	Mval is not a null string
+20$:	clr	r24
+	ret	r26
+
+;	If undef_inhibit is set, then all undefined values are equal to the null string:
+30$:	ldq	r28, a_undef_inhibit
+	ldq_u	r24, (r28)
+	extbl	r24, r28, r24
+	bne	r24, 10$		; it's set;  treat mval as a null string
+
+;	It's not set, so issue a message:
+	lda	sp, -8(sp)	; but first,
+	stq	r26, (sp)	; save the return address
+	mov	r0, r16
+	$call	UNDERR, args=<r16>, set_arg_info=false, nonstandard=true
+
+	ldq	r26, (sp)	; restore our return address
+	lda	sp, 8(sp)
+
+	ret	r26
+
+	$end_routine
+
+	.end

sr_alpha/op_forlcldo.m64

@@ -0,0 +1,51 @@
+	.title	OP_FORLCLDO
+; ###############################################################
+; #								#
+; #	Copyright 2001, 2003 Sanchez Computer Associates, Inc.	#
+; #								#
+; #	This source code contains the intellectual property	#
+; #	of its copyright holder(s), and is made available	#
+; #	under a license.  If you do not know the terms of	#
+; # 	the license, please stop and do not read further.	#
+; #								#
+; ###############################################################
+
+	G_MSF
+
+
+	$linkage_section
+
+a_frame_pointer:
+	.address frame_pointer
+
+
+	$code_section
+
+	$routine OP_FORLCLDOB, entry=OP_FORLCLDO_CA, aliases=<OP_FORLCLDOW,OP_FORLCLDOL>, kind=null
+	lda	sp, -16(sp)
+	stq	r13, 8(sp)
+	stq	r26, (sp)
+	mov	r27, r13
+	.base	r13, $ls
+
+	ldq	r1, a_frame_pointer
+	ldl	r1, (r1)
+
+;	Bump the return PC past the branch instruction following the jsr that got us here:
+	addl	r26, r16, r26		; length of branch sequence
+	stl	r26, msf$mpc_off(r1)	; and store it in the Mumps stack frame
+
+	$call	EXFUN_FRAME, set_arg_info=false, nonstandard=true
+
+	ldq	r12, a_frame_pointer
+	ldl	r12, (r12)
+	ldl	r9, msf$temps_ptr_off(r12)
+
+	ldq	r26, (sp)
+	ldq	r13, 8(sp)
+	lda	sp, 16(sp)
+	ret	r26
+
+	$end_routine
+
+	.end

sr_alpha/op_linestart.m64

@@ -0,0 +1,24 @@
+; ################################################################
+; #                                                              #
+; #      Copyright 2001, 2008 Fidelity Information Services, Inc #
+; #                                                              #
+; #      This source code contains the intellectual property     #
+; #      of its copyright holder(s), and is made available       #
+; #      under a license.  If you do not know the terms of       #
+; #      the license, please stop and do not read further.       #
+; #                                                              #
+; ################################################################
+
+	.title	op_linestart
+	G_MSF
+
+;	op_linestart - establish start of line in GT.M MUMPS stack frame
+
+	$routine	name=op_linestart,entry=op_linestart_ca,kind=null
+
+	stl	r26, msf$mpc_off(r12)
+	stl	r13, msf$ctxt_off(r12)
+
+	ret	r26
+
+	$end_routine	name=op_linestart

sr_alpha/op_pattern.m64

@@ -0,0 +1,51 @@
+; ################################################################
+; #                                                              #
+; #      Copyright 2001, 2008 Fidelity Information Services, Inc #
+; #                                                              #
+; #      This source code contains the intellectual property     #
+; #      of its copyright holder(s), and is made available       #
+; #      under a license.  If you do not know the terms of       #
+; #      the license, please stop and do not read further.       #
+; #                                                              #
+; ################################################################
+
+	.title	OP_PATTERN
+
+	mval$def
+
+	$routine OP_PATTERN, entry=OP_PATTERN_CA, kind=null
+	lda	sp, -16(sp)
+	stq	r13, 8(sp)
+	stq	r26, (sp)
+	mov	r27, r13
+	.base	r13, $ls
+
+	mov	r0, r16
+	mov	r1, r17
+
+	;
+	; This is an array of unaligned ints. If the first word is zero, then call do_pattern
+	; instead of do_patfixed. Only the low order byte is significant and so it is the only
+	; one we need to test. We would do this in assembly because (1) we need the assmembly
+	; routine anyway to save the return value into $TEST and (2) it saves an extra level of
+	; call linkage at the C level to do the decision here.
+	;
+	ldl	r28, mval$a_straddr(r1)
+	ldq_u	r24, (r28)
+	extbl	r24, r28, r24
+	beq	r24, 20$
+
+10$:	$call	DO_PATFIXED, args=<r16, r17>, set_arg_info=false, nonstandard=true
+
+15$:	mov	r0, r24
+	ldq	r26, (sp)
+	ldq	r13, 8(sp)
+	lda	sp, 16(sp)
+	ret	r26
+
+20$:	$call	DO_PATTERN, args=<r16, r17>, set_arg_info=false, nonstandard=true
+	br	15$
+
+	$end_routine
+
+	.end

sr_alpha/op_sorts_after.m64

@@ -0,0 +1,41 @@
+; ################################################################
+; #                                                              #
+; #      Copyright 2001, 2008 Fidelity Information Services, Inc #
+; #                                                              #
+; #      This source code contains the intellectual property     #
+; #      of its copyright holder(s), and is made available       #
+; #      under a license.  If you do not know the terms of       #
+; #      the license, please stop and do not read further.       #
+; #                                                              #
+; ################################################################
+
+	.title	OP_SORTS_AFTER
+
+; On entry:
+;	r0 -> mval for left hand side
+;	r1 -> mval for right hand side
+;
+; On exit:
+;	r24 < 0  : lhs ']] rhs  (lhs ]] rhs is false)
+;	r24 = 0  : lhs  =  rhs  (lhs ]] rhs is false)
+;	r24 > 0  : lhs  ]] rhs  (lhs ]] rhs is true)
+
+
+	$routine OP_SORTS_AFTER, entry=OP_SORTS_AFTER_CA, kind=null
+	lda	sp, -8(sp)
+	stq	r26, (sp)
+	.base	r27, $ls
+
+	mov	r0, r16
+	mov	r1, r17
+	$call	SORTS_AFTER, args=<r16, r17>, set_arg_info=false, nonstandard=true
+	mov	r0, r24
+
+	ldq	r26, (sp)
+	lda	sp, 8(sp)
+
+	ret	r26
+
+	$end_routine
+
+	.end

sr_alpha/pseudo_ret.m64

@@ -0,0 +1,37 @@
+; ################################################################
+; #                                                              #
+; #      Copyright 2001, 2008 Fidelity Information Services, Inc #
+; #                                                              #
+; #      This source code contains the intellectual property     #
+; #      of its copyright holder(s), and is made available       #
+; #      under a license.  If you do not know the terms of       #
+; #      the license, please stop and do not read further.       #
+; #                                                              #
+; ################################################################
+
+	.title	PSEUDO_RET
+
+;	PSEUDO_RET calls opp_ret (which doesn't return).  It executes in a
+;	GT.M MUMPS stack frame and is, in fact, normally entered via a
+;	getframe/ret instruction sequence.
+;
+;	entry:
+;		r13 -	address of PSEUDO_RET's procedure descriptor (not r27)
+;
+;	WARNING: because PSEUDO_RET is designed to be invoked from a GT.M
+;	MUMPS stack frame, it does not conform to the Alpha calling
+;	standard and cannot be invoked from any high-level language.  The
+;	invoker should load the address of PSEUDO_RET's procedure descriptor
+;	into r13, not r27.
+
+
+	$code_section
+
+	$routine	PSEUDO_RET, entry=PSEUDO_RET_CA, kind=null
+	.base	r13, $ls
+
+	$call	opp_ret, set_arg_info=false, nonstandard=true
+
+	$end_routine
+
+	.end

sr_alpha/zbreaksp.h

@@ -0,0 +1,28 @@
+/****************************************************************
+ *								*
+ *	Copyright 2001, 2009 Fidelity Information Services, Inc	*
+ *								*
+ *	This source code contains the intellectual property	*
+ *	of its copyright holder(s), and is made available	*
+ *	under a license.  If you do not know the terms of	*
+ *	the license, please stop and do not read further.	*
+ *								*
+ ****************************************************************/
+
+typedef unsigned short	zb_code;
+#define ZB_CODE_MASK	0xffff
+#define INST_TYPE	zb_code
+
+/* The ZBreak command operates by finding the generated code for the op_linestart or op_linefetch for the source
+ * line in question and changing the offset in the transfer table load address instruction from the op_linestart or
+ * op_linefetch offset to the appropriate zbreak functionality opcode offset.
+ * In some platforms(IA64 and ZOS) since the INSTRUCTION LAYOUT is complex we need following
+ * macros for instruction manipulation.
+ *      EXTRACT_OFFSET_TO_M_OPCODE
+ *      FIX_OFFSET_WITH_ZBREAK_OFFSET
+ *      EXTRACT_AND_UPDATE_INST
+ * These macros are called only when COMPLEX_INSTRUCTION_UPDATE is defined
+ * If COMPLEX_INSTRUCTION_UPDATE is not defined portable code in the caller of these macros
+ * is invoked.
+ */
+#undef COMPLEX_INSTRUCTION_UPDATE

sr_i386/CVS/Entries

@@ -0,0 +1,112 @@
+/aswp.s/1.1.1.1/Wed May 16 14:01:20 2001//
+/auto_zlink.c/1.3/Fri Nov  2 03:00:12 2012//
+/auto_zlink.h/1.2/Fri Nov  2 03:00:13 2012//
+/call_dm.s/1.2/Fri Nov  2 03:00:13 2012//
+/caller_id.s/1.1.1.1/Wed May 16 14:01:20 2001//
+/callg.s/1.2/Fri Nov  2 03:00:13 2012//
+/ci_restart.s/1.2/Tue Aug 19 19:03:07 2003//
+/cmerrors_ctl.c/1.2/Fri Jan 11 04:43:23 2013//
+/cmierrors_ctl.c/1.2/Fri Jan 11 04:43:23 2013//
+/compswap.s/1.1.1.1/Wed May 16 14:01:20 2001//
+/dm_start.s/1.3/Fri Nov  2 03:00:13 2012//
+/emit_code.c/1.5/Wed Oct 23 03:49:21 2013//
+/emit_code.h/1.1.1.1/Wed May 16 14:01:20 2001//
+/error.si/1.2/Fri Nov  2 03:00:13 2012//
+/find_line_call.c/1.3/Fri Nov  2 03:00:13 2012//
+/follow.s/1.1.1.1/Wed May 16 14:01:20 2001//
+/g_msf.si/1.3/Fri Nov  2 03:00:13 2012//
+/gdeerrors_ctl.c/1.2/Fri Jan 11 04:43:23 2013//
+/incr_link.c/1.3/Fri Nov  2 03:00:13 2012//
+/linkage.si/1.1.1.1/Wed May 16 14:01:20 2001//
+/make_cimode.c/1.2/Fri Nov  2 03:00:13 2012//
+/make_dmode.c/1.4/Fri Nov  2 03:00:13 2012//
+/masscomp.h/1.2/Thu Dec 13 21:19:49 2001//
+/merrors_ansi.h/1.4/Wed Oct 23 03:49:21 2013//
+/merrors_ctl.c/1.4/Wed Oct 23 03:49:22 2013//
+/mint2mval.s/1.1.1.1/Wed May 16 14:01:20 2001//
+/mum_tstart.s/1.3/Thu Jun 13 14:23:09 2002//
+/mval2bool.s/1.2/Fri Nov  2 03:00:13 2012//
+/mval2mint.s/1.2/Fri Nov  2 03:00:13 2012//
+/mval2num.s/1.2/Fri Nov  2 03:00:13 2012//
+/mval_def.si/1.4/Fri Jan 11 04:43:23 2013//
+/obj_file.c/1.5/Fri Nov  2 03:00:13 2012//
+/op_bkpt.s/1.3/Fri Nov  2 03:00:13 2012//
+/op_call.s/1.1.1.1/Wed May 16 14:01:21 2001//
+/op_callsp.s/1.1.1.1/Wed May 16 14:01:21 2001//
+/op_contain.s/1.2/Fri Nov  2 03:00:13 2012//
+/op_currtn.s/1.2/Fri Nov  2 03:00:13 2012//
+/op_equ.s/1.1.1.1/Wed May 16 14:01:21 2001//
+/op_equnul.s/1.2/Fri Nov  2 03:00:13 2012//
+/op_exfun.s/1.3/Fri Nov  2 03:00:13 2012//
+/op_extcall.s/1.2/Fri Nov  2 03:00:14 2012//
+/op_extexfun.s/1.3/Fri Nov  2 03:00:14 2012//
+/op_extjmp.s/1.3/Fri Nov  2 03:00:14 2012//
+/op_fetchintrrpt.s/1.2/Fri Nov  2 03:00:14 2012//
+/op_fnget.s/1.2/Fri Nov  2 03:00:14 2012//
+/op_fnzextract.s/1.1/Fri Nov  2 03:00:14 2012//
+/op_follow.s/1.2/Fri Nov  2 03:00:14 2012//
+/op_forcenum.s/1.2/Fri Nov  2 03:00:14 2012//
+/op_forchk1.s/1.1.1.1/Wed May 16 14:01:21 2001//
+/op_forinit.s/1.2/Fri Nov  2 03:00:14 2012//
+/op_forintrrpt.s/1.2/Fri Nov  2 03:00:14 2012//
+/op_forlcldo.s/1.1.1.1/Wed May 16 14:01:21 2001//
+/op_forloop.s/1.3/Fri Jan 11 04:43:23 2013//
+/op_gettruth.s/1.1.1.1/Wed May 16 14:01:21 2001//
+/op_iretmvad.s/1.1.1.1/Wed May 16 14:01:21 2001//
+/op_linefetch.s/1.2/Fri Nov  2 03:00:14 2012//
+/op_linestart.s/1.1.1.1/Wed May 16 14:01:21 2001//
+/op_mprofcall.s/1.1.1.1/Wed May 16 14:01:21 2001//
+/op_mprofcallsp.s/1.1.1.1/Wed May 16 14:01:21 2001//
+/op_mprofexfun.s/1.3/Fri Nov  2 03:00:14 2012//
+/op_mprofextcall.s/1.2/Fri Nov  2 03:00:14 2012//
+/op_mprofextexfun.s/1.3/Fri Nov  2 03:00:14 2012//
+/op_mprofforchk1.s/1.1/Fri Nov  2 03:00:14 2012//
+/op_mprofforlcldo.s/1.2/Fri Nov  2 03:00:14 2012//
+/op_mproflinefetch.s/1.3/Fri Nov  2 03:00:14 2012//
+/op_mproflinestart.s/1.3/Fri Nov  2 03:00:14 2012//
+/op_neg.s/1.2/Fri Nov  2 03:00:14 2012//
+/op_numcmp.s/1.1.1.1/Wed May 16 14:01:21 2001//
+/op_pattern.s/1.2/Thu Jun 13 14:23:21 2002//
+/op_restartpc.s/1.2/Thu Dec 13 21:19:53 2001//
+/op_retarg.s/1.2/Fri Nov  2 03:00:14 2012//
+/op_sorts_after.s/1.1.1.1/Wed May 16 14:01:21 2001//
+/op_startintrrpt.s/1.3/Thu Jun 13 14:23:22 2002//
+/op_sto.s/1.2/Fri Nov  2 03:00:14 2012//
+/op_zhelp.s/1.1.1.1/Wed May 16 14:01:21 2001//
+/opp_break.s/1.1.1.1/Wed May 16 14:01:20 2001//
+/opp_commarg.s/1.1.1.1/Wed May 16 14:01:20 2001//
+/opp_dmode.s/1.1.1.1/Wed May 16 14:01:20 2001//
+/opp_hardret.s/1.2/Fri Nov  2 03:00:15 2012//
+/opp_inddevparms.s/1.1.1.1/Wed May 16 14:01:20 2001//
+/opp_indfnname.s/1.1.1.1/Wed May 16 14:01:20 2001//
+/opp_indfun.s/1.1.1.1/Wed May 16 14:01:20 2001//
+/opp_indglvn.s/1.1.1.1/Wed May 16 14:01:21 2001//
+/opp_indincr.s/1.1/Fri Nov  2 03:00:15 2012//
+/opp_indlvadr.s/1.1.1.1/Wed May 16 14:01:21 2001//
+/opp_indlvarg.s/1.1.1.1/Wed May 16 14:01:21 2001//
+/opp_indlvnamadr.s/1.1.1.1/Wed May 16 14:01:21 2001//
+/opp_indmerge.s/1.1.1.1/Wed May 16 14:01:21 2001//
+/opp_indpat.s/1.1.1.1/Wed May 16 14:01:21 2001//
+/opp_indrzshow.s/1.1.1.1/Wed May 16 14:01:21 2001//
+/opp_indsavglvn.s/1.1/Fri Jan 11 05:31:38 2013//
+/opp_indsavlvn.s/1.1/Fri Jan 11 05:31:38 2013//
+/opp_indset.s/1.1.1.1/Wed May 16 14:01:21 2001//
+/opp_indtext.s/1.2/Thu Jun 13 14:23:24 2002//
+/opp_iretmval.s/1.3/Fri Jan 11 04:43:23 2013//
+/opp_newintrinsic.s/1.1/Thu Dec 13 21:04:04 2001//
+/opp_newvar.s/1.1.1.1/Wed May 16 14:01:21 2001//
+/opp_ret.s/1.1.1.1/Wed May 16 14:01:21 2001//
+/opp_rterror.s/1.2/Thu Jun 13 14:23:25 2002//
+/opp_svput.s/1.2/Thu Jun 13 14:23:26 2002//
+/opp_tcommit.s/1.2/Fri Nov  2 03:00:15 2012//
+/opp_trestart.s/1.2/Fri Nov  2 03:00:15 2012//
+/opp_trollback.s/1.1/Tue Aug 19 18:50:41 2003//
+/opp_tstart.s/1.2/Fri Nov  2 03:00:15 2012//
+/opp_xnew.s/1.1.1.1/Wed May 16 14:01:21 2001//
+/opp_zcont.s/1.2/Fri Nov  2 03:00:15 2012//
+/opp_zg1.s/1.1/Fri Nov  2 03:00:15 2012//
+/opp_zgoto.s/1.1/Fri Nov  2 03:00:15 2012//
+/pseudo_ret.s/1.1.1.1/Wed May 16 14:01:21 2001//
+/ttt.c/1.3/Mon Jul  1 22:46:01 2013//
+/zbreaksp.h/1.2/Fri Nov  2 03:00:15 2012//
+D

sr_i386/CVS/Entries.Extra

@@ -0,0 +1,111 @@
+/aswp.s////*////
+/auto_zlink.c////*////
+/auto_zlink.h////*////
+/call_dm.s////*////
+/caller_id.s////*////
+/callg.s////*////
+/ci_restart.s////*////
+/cmerrors_ctl.c////*////
+/cmierrors_ctl.c////*////
+/compswap.s////*////
+/dm_start.s////*////
+/emit_code.c////*////
+/emit_code.h////*////
+/error.si////*////
+/find_line_call.c////*////
+/follow.s////*////
+/g_msf.si////*////
+/gdeerrors_ctl.c////*////
+/incr_link.c////*////
+/linkage.si////*////
+/make_cimode.c////*////
+/make_dmode.c////*////
+/masscomp.h////*////
+/merrors_ansi.h////*////
+/merrors_ctl.c////*////
+/mint2mval.s////*////
+/mum_tstart.s////*////
+/mval2bool.s////*////
+/mval2mint.s////*////
+/mval2num.s////*////
+/mval_def.si////*////
+/obj_file.c////*////
+/op_bkpt.s////*////
+/op_call.s////*////
+/op_callsp.s////*////
+/op_contain.s////*////
+/op_currtn.s////*////
+/op_equ.s////*////
+/op_equnul.s////*////
+/op_exfun.s////*////
+/op_extcall.s////*////
+/op_extexfun.s////*////
+/op_extjmp.s////*////
+/op_fetchintrrpt.s////*////
+/op_fnget.s////*////
+/op_fnzextract.s////*////
+/op_follow.s////*////
+/op_forcenum.s////*////
+/op_forchk1.s////*////
+/op_forinit.s////*////
+/op_forintrrpt.s////*////
+/op_forlcldo.s////*////
+/op_forloop.s////*////
+/op_gettruth.s////*////
+/op_iretmvad.s////*////
+/op_linefetch.s////*////
+/op_linestart.s////*////
+/op_mprofcall.s////*////
+/op_mprofcallsp.s////*////
+/op_mprofexfun.s////*////
+/op_mprofextcall.s////*////
+/op_mprofextexfun.s////*////
+/op_mprofforchk1.s////*////
+/op_mprofforlcldo.s////*////
+/op_mproflinefetch.s////*////
+/op_mproflinestart.s////*////
+/op_neg.s////*////
+/op_numcmp.s////*////
+/op_pattern.s////*////
+/op_restartpc.s////*////
+/op_retarg.s////*////
+/op_sorts_after.s////*////
+/op_startintrrpt.s////*////
+/op_sto.s////*////
+/op_zhelp.s////*////
+/opp_break.s////*////
+/opp_commarg.s////*////
+/opp_dmode.s////*////
+/opp_hardret.s////*////
+/opp_inddevparms.s////*////
+/opp_indfnname.s////*////
+/opp_indfun.s////*////
+/opp_indglvn.s////*////
+/opp_indincr.s////*////
+/opp_indlvadr.s////*////
+/opp_indlvarg.s////*////
+/opp_indlvnamadr.s////*////
+/opp_indmerge.s////*////
+/opp_indpat.s////*////
+/opp_indrzshow.s////*////
+/opp_indsavglvn.s////*////
+/opp_indsavlvn.s////*////
+/opp_indset.s////*////
+/opp_indtext.s////*////
+/opp_iretmval.s////*////
+/opp_newintrinsic.s////*////
+/opp_newvar.s////*////
+/opp_ret.s////*////
+/opp_rterror.s////*////
+/opp_svput.s////*////
+/opp_tcommit.s////*////
+/opp_trestart.s////*////
+/opp_trollback.s////*////
+/opp_tstart.s////*////
+/opp_xnew.s////*////
+/opp_zcont.s////*////
+/opp_zg1.s////*////
+/opp_zgoto.s////*////
+/pseudo_ret.s////*////
+/ttt.c////*////
+/zbreaksp.h////*////

sr_i386/CVS/Repository

@@ -0,0 +1 @@
+gtm/sr_i386

sr_i386/CVS/Root

@@ -0,0 +1 @@
+:pserver:anonymous@fis-gtm.cvs.sourceforge.net:/cvsroot/fis-gtm

sr_i386/auto_zlink.c

@@ -15,9 +15,9 @@
 
 #include "i386.h"
 #include "urx.h"
-#include "rtnhdr.h"
+#include <rtnhdr.h>
 #include "op.h"
-#include "auto_zlink.h"
+#include <auto_zlink.h>
 
 #define PEA_SZ		5
 #define XFER_BYTE_SZ	3

sr_i386/cmerrors_ctl.c

@@ -0,0 +1,35 @@
+/****************************************************************
+ *								*
+ *	Copyright 2001,2013 Fidelity Information Services, Inc	*
+ *								*
+ *	This source code contains the intellectual property	*
+ *	of its copyright holder(s), and is made available	*
+ *	under a license.  If you do not know the terms of	*
+ *	the license, please stop and do not read further.	*
+ *								*
+ ****************************************************************/
+
+#include "mdef.h"
+#include "error.h"
+
+LITDEF	err_msg cmerrors[] = {
+	"INVPROT", "Invalid protocol specified by remote partner", 0,
+	"REGNTFND", "Region referenced not initialized", 0,
+	"CMINTQUE", "Interlock failure accessing GT.CM server queue", 0,
+	"INVINTMSG", "Invalid interrupt message received.", 0,
+	"CMEXCDASTLM", "Exceeded AST limit. Cannot open database.", 0,
+	"CMSYSSRV", "Error doing system service, status:", 0,
+};
+
+LITDEF	int CMERR_INVPROT = 150568970;
+LITDEF	int CMERR_REGNTFND = 150568978;
+LITDEF	int CMERR_CMINTQUE = 150568988;
+LITDEF	int CMERR_INVINTMSG = 150568994;
+LITDEF	int CMERR_CMEXCDASTLM = 150569002;
+LITDEF	int CMERR_CMSYSSRV = 150569010;
+
+GBLDEF	err_ctl cmerrors_ctl = {
+	249,
+	"GTCM",
+	&cmerrors[0],
+	6};

sr_i386/cmierrors_ctl.c

@@ -0,0 +1,73 @@
+/****************************************************************
+ *								*
+ *	Copyright 2001,2013 Fidelity Information Services, Inc	*
+ *								*
+ *	This source code contains the intellectual property	*
+ *	of its copyright holder(s), and is made available	*
+ *	under a license.  If you do not know the terms of	*
+ *	the license, please stop and do not read further.	*
+ *								*
+ ****************************************************************/
+
+#include "mdef.h"
+#include "error.h"
+
+LITDEF	err_msg cmierrors[] = {
+	"DCNINPROG", "Attempt to initiate operation while disconnect was in progress", 0,
+	"LNKNOTIDLE", "Attempt to initiate operation before previous operation completed", 0,
+	"ASSERT", "Assert failed !AD line !UL", 3,
+	"CMICHECK", "Internal CMI error. Report to your GT.M Support Channel.", 0,
+	"NETFAIL", "Failure of Net operation", 0,
+	"BADPORT", "Environment variable GTCM_TCP_PORT is not an integer", 0,
+	"NOTND", "tnd argument to cmi_init is NULL", 0,
+	"OVERRUN", "mbf argument in CLB is not large enough for packet", 0,
+	"NOSERVENT", "Sevices data lookup failure", 0,
+	"BADIPADDRPORT", "Bad specification of [ip address:port] in tnd", 0,
+	"REASON_CONNECT", "Incoming connection", 0,
+	"REASON_INTMSG", "Incoming urgent data", 0,
+	"REASON_DISCON", "Disconnect encountered", 0,
+	"REASON_ABORT", "Link aborted", 0,
+	"REASON_EXIT", "Exit", 0,
+	"REASON_PATHLOST", "Network path lost", 0,
+	"REASON_PROTOCOL", "Protocol error", 0,
+	"REASON_THIRDPARTY", "Thirdparty error", 0,
+	"REASON_TIMEOUT", "Network timeout", 0,
+	"REASON_NETSHUT", "Shutdown received", 0,
+	"REASON_REJECT", "Connection rejected", 0,
+	"REASON_IODONE", "I/O done", 0,
+	"REASON_OVERRUN", "Input overran buffer", 0,
+	"REASON_STATUS", "Status", 0,
+	"REASON_CONFIRM", "Confirm", 0,
+};
+
+LITDEF	int CMI_DCNINPROG = 150634508;
+LITDEF	int CMI_LNKNOTIDLE = 150634516;
+LITDEF	int CMI_ASSERT = 150634522;
+LITDEF	int CMI_CMICHECK = 150634532;
+LITDEF	int CMI_NETFAIL = 150634538;
+LITDEF	int CMI_BADPORT = 150634546;
+LITDEF	int CMI_NOTND = 150634556;
+LITDEF	int CMI_OVERRUN = 150634562;
+LITDEF	int CMI_NOSERVENT = 150634570;
+LITDEF	int CMI_BADIPADDRPORT = 150634578;
+LITDEF	int CMI_REASON_CONNECT = 150634586;
+LITDEF	int CMI_REASON_INTMSG = 150634594;
+LITDEF	int CMI_REASON_DISCON = 150634602;
+LITDEF	int CMI_REASON_ABORT = 150634610;
+LITDEF	int CMI_REASON_EXIT = 150634618;
+LITDEF	int CMI_REASON_PATHLOST = 150634626;
+LITDEF	int CMI_REASON_PROTOCOL = 150634634;
+LITDEF	int CMI_REASON_THIRDPARTY = 150634642;
+LITDEF	int CMI_REASON_TIMEOUT = 150634650;
+LITDEF	int CMI_REASON_NETSHUT = 150634658;
+LITDEF	int CMI_REASON_REJECT = 150634666;
+LITDEF	int CMI_REASON_IODONE = 150634674;
+LITDEF	int CMI_REASON_OVERRUN = 150634682;
+LITDEF	int CMI_REASON_STATUS = 150634690;
+LITDEF	int CMI_REASON_CONFIRM = 150634698;
+
+GBLDEF	err_ctl cmierrors_ctl = {
+	250,
+	"CMI",
+	&cmierrors[0],
+	25};

sr_i386/emit_code.c

@@ -1,6 +1,6 @@
 /****************************************************************
  *								*
- *	Copyright 2001, 2009 Fidelity Information Services, Inc	*
+ *	Copyright 2001, 2013 Fidelity Information Services, Inc	*
  *								*
  *	This source code contains the intellectual property	*
  *	of its copyright holder(s), and is made available	*
@@ -12,7 +12,7 @@
 #include "mdef.h"
 
 #include "compiler.h"
-#include "rtnhdr.h"
+#include <rtnhdr.h>
 #include "stack_frame.h"
 #include "opcode.h"
 #include "xfer_enum.h"
@@ -23,7 +23,7 @@
 #include "obj_gen.h"
 #include "i386.h"
 #include "obj_file.h"
-#include "emit_code.h"
+#include <emit_code.h>
 #include "hashtab_mname.h"
 #include "stddef.h"
 
@@ -87,6 +87,9 @@ GBLDEF uint4	txtrel_cnt;	/* count of text relocation records */
 /* its referenced in ind_code.c */
 GBLDEF int              calculated_code_size, generated_code_size;
 
+error_def(ERR_UNIMPLOP);
+error_def(ERR_MAXARGCNT);
+
 void trip_gen(triple *ct)
 {
 	oprtype		**sopr, *opr;	/* triple operand */
@@ -99,8 +102,6 @@ void trip_gen(triple *ct)
 	oprtype		*irep_opr;
 	short		*repl, repcnt;	/* temp irep ptr */
 	int4		off;
-	error_def	(ERR_UNIMPLOP);
-	error_def	(ERR_MAXARGCNT);
 
 	tp = ttt[ct->opcode];
 	if (tp <= 0)
@@ -125,8 +126,8 @@ void trip_gen(triple *ct)
 				continue;
 			}
 			*sopr++ = opr;
-			if (sopr >= ARRAYTOP(saved_opr))
+			if (sopr >= ARRAYTOP(saved_opr))	/* user-visible max args is MAX_ARGS - 3 */
-				rts_error(VARLSTCNT(3) ERR_MAXARGCNT, 1, MAX_ARGS);
+				rts_error_csa(CSA_ARG(NULL) VARLSTCNT(3) ERR_MAXARGCNT, 1, MAX_ARGS - 3);
 		}
 		opr++;
 	}
@@ -752,8 +753,6 @@ void emit_trip(generic_op op, oprtype *opr, bool val_output, unsigned char use_r
 	int4			offset, literal;
 	triple			*ct;
 
-	error_def		(ERR_UNIMPLOP);
-
 	if (opr->oprclass == TRIP_REF)
 	{
 		ct = opr->oprval.tref;
@@ -790,7 +789,7 @@ void emit_trip(generic_op op, oprtype *opr, bool val_output, unsigned char use_r
 						temp_reg = I386_REG_ECX;
 						break;
 					default:
-						rts_error(VARLSTCNT(1) ERR_UNIMPLOP);
+						rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) ERR_UNIMPLOP);
 						break;
 					}
 					pc_value_idx = code_idx + 5;
@@ -832,7 +831,7 @@ void emit_trip(generic_op op, oprtype *opr, bool val_output, unsigned char use_r
 						code_idx += 1 + SIZEOF(int4);
 					break;
 				default:
-					rts_error(VARLSTCNT(1) ERR_UNIMPLOP);
+					rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) ERR_UNIMPLOP);
 					break;
 				}
 				break;
@@ -940,7 +939,7 @@ void emit_trip(generic_op op, oprtype *opr, bool val_output, unsigned char use_r
 					emit_base_offset(use_reg, base_reg, offset);
 				break;
 			default:
-				rts_error(VARLSTCNT(1) ERR_UNIMPLOP);
+				rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) ERR_UNIMPLOP);
 				break;
 			}
 			break;
@@ -970,7 +969,7 @@ void emit_trip(generic_op op, oprtype *opr, bool val_output, unsigned char use_r
 						temp_reg = I386_REG_ECX;
 						break;
 					default:
-						rts_error(VARLSTCNT(1) ERR_UNIMPLOP);
+						rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) ERR_UNIMPLOP);
 						break;
 					}
 					code_buf[code_idx++] = I386_INS_CALL_Jv;
@@ -1032,7 +1031,7 @@ void emit_trip(generic_op op, oprtype *opr, bool val_output, unsigned char use_r
 					}
 					break;
 				default:
-					rts_error(VARLSTCNT(1) ERR_UNIMPLOP);
+					rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) ERR_UNIMPLOP);
 					break;
 				}
 				break;
@@ -1146,7 +1145,7 @@ void emit_trip(generic_op op, oprtype *opr, bool val_output, unsigned char use_r
 					emit_base_offset(use_reg, base_reg, offset);
 				break;
 			default:
-				rts_error(VARLSTCNT(1) ERR_UNIMPLOP);
+				rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) ERR_UNIMPLOP);
 				break;
 			}
 			break;
@@ -1175,9 +1174,6 @@ void emit_xfer(short xfer)
 
 void emit_op_base_offset(generic_op op, short base_reg, int offset, short use_reg)
 {
-
-	error_def	(ERR_UNIMPLOP);
-
 	switch (op)
 	{
 	case CLEAR:
@@ -1221,7 +1217,7 @@ void emit_op_base_offset(generic_op op, short base_reg, int offset, short use_re
 		code_buf[code_idx++] = 0;
 		break;
 	default:
-		rts_error(VARLSTCNT(1) ERR_UNIMPLOP);
+		rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) ERR_UNIMPLOP);
 		break;
 	}
 }
@@ -1271,8 +1267,6 @@ void emit_base_offset (short reg_opcode, short base_reg, int4 offset)
 
 void emit_op_alit (generic_op op, unsigned char use_reg)
 {
-	error_def	(ERR_UNIMPLOP);
-
 	switch (op)
 	{
 	case LOAD_ADDRESS:
@@ -1289,7 +1283,7 @@ void emit_op_alit (generic_op op, unsigned char use_reg)
 		code_buf[code_idx++] = I386_INS_PUSH_Iv;
 		break;
 	default:
-		rts_error(VARLSTCNT(1) ERR_UNIMPLOP);
+		rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) ERR_UNIMPLOP);
 		break;
 	}
 }

sr_i386/error.si

@@ -1,6 +1,6 @@
 #################################################################
 #								#
-#	Copyright 2001, 2007 Fidelity Information Services, Inc	#
+#	Copyright 2001, 2012 Fidelity Information Services, Inc	#
 #								#
 #	This source code contains the intellectual property	#
 #	of its copyright holder(s), and is made available	#
@@ -36,16 +36,13 @@ chnd_jmp	=	12
 .else
 #	setjmp is really __sigsetjmp(env,0)
 .extern	__sigsetjmp
+.extern gtm_asm_establish
 .endif
 
 	.sbttl	error.si    ESTABLISH
 .macro ESTABLISH  x, label
-	addl	$chnd_size,ctxt			# ctxt++
+        call	gtm_asm_establish		# Bulk of ESTABLISH macro
 	movl	ctxt,%eax
-	movl	active_ch,%edx			# ctxt->save_active_ch = active_ch
-	movl	%edx,chnd_save_active(%eax)
-	movl	$0,chnd_ch_active(%eax)		# ctxt->ch_active = FALSE
-	movl	%eax,active_ch			# active_ch = ctxt
 	movl	$\x,chnd_ch(%eax)		# ctxt->ch = x
 	addl	$chnd_jmp,%eax			# setjmp(ctxt->jmp)
 .ifndef cygwin

sr_i386/find_line_call.c

@@ -12,7 +12,7 @@
 #include "mdef.h"
 #include "xfer_enum.h"
 #include "i386.h"
-#include "rtnhdr.h"	/* Needed by zbreak.h */
+#include <rtnhdr.h>	/* Needed by zbreak.h */
 #include "zbreak.h"
 
 zb_code  *find_line_call(void *addr)

sr_i386/gdeerrors_ctl.c

@@ -0,0 +1,139 @@
+/****************************************************************
+ *								*
+ *	Copyright 2001,2013 Fidelity Information Services, Inc	*
+ *								*
+ *	This source code contains the intellectual property	*
+ *	of its copyright holder(s), and is made available	*
+ *	under a license.  If you do not know the terms of	*
+ *	the license, please stop and do not read further.	*
+ *								*
+ ****************************************************************/
+
+#include "mdef.h"
+#include "error.h"
+
+LITDEF	err_msg gdeerrors[] = {
+	"BLKSIZ512", "Block size !AD rounds to !AD", 4,
+	"EXECOM", "Executing command file !AD", 2,
+	"FILENOTFND", "File !AD not found", 2,
+	"GDCREATE", "Creating Global Directory file !/	!AD", 2,
+	"GDECHECK", "Internal GDE consistency check", 0,
+	"GDUNKNFMT", "!AD !/	is not formatted as a Global Directory", 2,
+	"GDUPDATE", "Updating Global Directory file !/	!AD", 2,
+	"GDUSEDEFS", "Using defaults for Global Directory !/	!AD", 2,
+	"ILLCHAR", "!AD is not a legal character in this context", 2,
+	"INPINTEG", "Input integrity error -- aborting load", 0,
+	"KEYTOOBIG", "But record size !AD can only support key size !AD", 4,
+	"KEYSIZIS", "Key size is !AD", 2,
+	"KEYWRDAMB", "!AD is ambiguous for !AD", 4,
+	"KEYWRDBAD", "!AD is not a valid !AD", 4,
+	"LOADGD", "Loading Global Directory file !/	!AD", 2,
+	"LOGOFF", "No longer logging to file !AD", 2,
+	"LOGON", "Logging to file !AD", 2,
+	"LVSTARALON", "The * name cannot be deleted or renamed", 0,
+	"MAPBAD", "!AD !AD for !AD !AD does not exist", 8,
+	"MAPDUP", "!AD !AD and !AD both map to !AD !AD", 10,
+	"NAMSTARTBAD", "!AD must start with '%' or an alphabetic character", 2,
+	"NOACTION", "Not updating Global Directory !AD", 2,
+	"RPAREN", "List must end with right parenthesis or continue with comma", 0,
+	"NOEXIT", "Cannot exit because of verification failure", 0,
+	"NOLOG", "Logging is currently disabled!/ Log file is !AD.", 2,
+	"NOVALUE", "Qualifier !AD does not take a value", 2,
+	"NONEGATE", "Qualifier !AD cannot be negated", 2,
+	"OBJDUP", "!AD !AD already exists", 4,
+	"OBJNOTADD", "Not adding !AD !AD", 4,
+	"OBJNOTCHG", "Not changing !AD !AD", 4,
+	"OBJNOTFND", "!AD !AD does not exist", 4,
+	"OBJREQD", "!AD required", 2,
+	"PREFIXBAD", "!AD must start with an alphabetic character to be a !AD", 4,
+	"QUALBAD", "!AD is not a valid qualifier", 2,
+	"QUALDUP", "!AD qualifier appears more than once in the list", 2,
+	"QUALREQD", "!AD required", 2,
+	"RECTOOBIG", "Block size !AD and !AD reserved bytes limit record size to !AD", 6,
+	"RECSIZIS", "Record size is !AD", 2,
+	"REGIS", "in region !AD", 2,
+	"SEGIS", "in !AD segment !AD", 4,
+	"VALTOOBIG", "!AD is larger than the maximum of !AD for a !AD", 6,
+	"VALTOOLONG", "!AD exceeds the maximum length of !AD for a !AD", 6,
+	"VALTOOSMALL", "!AD is less than the minimum of !AD for a !AD", 6,
+	"VALUEBAD", "!AD is not a valid !AD", 4,
+	"VALUEREQD", "Qualifier !AD requires a value", 2,
+	"VERIFY", "Verification !AD", 2,
+	"BUFSIZIS", "Journal Buffer size is !AD", 2,
+	"BUFTOOSMALL", "But block size !AD requires buffer size !AD", 4,
+	"MMNOBEFORIMG", "MM segments do not support before image jounaling", 0,
+	"NOJNL", "!AD segments do not support journaling", 2,
+	"GDREADERR", "Error reading Global Directory: !AD", 2,
+	"GDNOTSET", "Global Directory not changed because the current GD cannot be written", 0,
+	"INVGBLDIR", "Invalid Global Directory spec: !AD.!/Continuing with !AD", 4,
+	"WRITEERROR", "Cannot exit because of write failure.  Reason for failure: !AD", 2,
+	"NONASCII", "!AD is illegal for a !AD as it contains non-ASCII characters", 4,
+	"CRYPTNOMM", "!AD is an encrypted database. Cannot support MM access method.", 2,
+	"JNLALLOCGROW", "Increased Journal ALLOCATION from [!AD blocks] to [!AD blocks] to match AUTOSWITCHLIMIT for !AD !AD", 8,
+	"KEYFORBLK", "But block size !AD can only support key size !AD", 4,
+};
+
+LITDEF	int GDE_BLKSIZ512 = 150503435;
+LITDEF	int GDE_EXECOM = 150503443;
+LITDEF	int GDE_FILENOTFND = 150503450;
+LITDEF	int GDE_GDCREATE = 150503459;
+LITDEF	int GDE_GDECHECK = 150503467;
+LITDEF	int GDE_GDUNKNFMT = 150503475;
+LITDEF	int GDE_GDUPDATE = 150503483;
+LITDEF	int GDE_GDUSEDEFS = 150503491;
+LITDEF	int GDE_ILLCHAR = 150503498;
+LITDEF	int GDE_INPINTEG = 150503508;
+LITDEF	int GDE_KEYTOOBIG = 150503515;
+LITDEF	int GDE_KEYSIZIS = 150503523;
+LITDEF	int GDE_KEYWRDAMB = 150503530;
+LITDEF	int GDE_KEYWRDBAD = 150503538;
+LITDEF	int GDE_LOADGD = 150503547;
+LITDEF	int GDE_LOGOFF = 150503555;
+LITDEF	int GDE_LOGON = 150503563;
+LITDEF	int GDE_LVSTARALON = 150503570;
+LITDEF	int GDE_MAPBAD = 150503579;
+LITDEF	int GDE_MAPDUP = 150503587;
+LITDEF	int GDE_NAMSTARTBAD = 150503594;
+LITDEF	int GDE_NOACTION = 150503603;
+LITDEF	int GDE_RPAREN = 150503610;
+LITDEF	int GDE_NOEXIT = 150503619;
+LITDEF	int GDE_NOLOG = 150503627;
+LITDEF	int GDE_NOVALUE = 150503634;
+LITDEF	int GDE_NONEGATE = 150503642;
+LITDEF	int GDE_OBJDUP = 150503650;
+LITDEF	int GDE_OBJNOTADD = 150503658;
+LITDEF	int GDE_OBJNOTCHG = 150503666;
+LITDEF	int GDE_OBJNOTFND = 150503674;
+LITDEF	int GDE_OBJREQD = 150503682;
+LITDEF	int GDE_PREFIXBAD = 150503690;
+LITDEF	int GDE_QUALBAD = 150503698;
+LITDEF	int GDE_QUALDUP = 150503706;
+LITDEF	int GDE_QUALREQD = 150503714;
+LITDEF	int GDE_RECTOOBIG = 150503723;
+LITDEF	int GDE_RECSIZIS = 150503731;
+LITDEF	int GDE_REGIS = 150503739;
+LITDEF	int GDE_SEGIS = 150503747;
+LITDEF	int GDE_VALTOOBIG = 150503755;
+LITDEF	int GDE_VALTOOLONG = 150503762;
+LITDEF	int GDE_VALTOOSMALL = 150503771;
+LITDEF	int GDE_VALUEBAD = 150503778;
+LITDEF	int GDE_VALUEREQD = 150503786;
+LITDEF	int GDE_VERIFY = 150503795;
+LITDEF	int GDE_BUFSIZIS = 150503803;
+LITDEF	int GDE_BUFTOOSMALL = 150503811;
+LITDEF	int GDE_MMNOBEFORIMG = 150503819;
+LITDEF	int GDE_NOJNL = 150503827;
+LITDEF	int GDE_GDREADERR = 150503835;
+LITDEF	int GDE_GDNOTSET = 150503843;
+LITDEF	int GDE_INVGBLDIR = 150503851;
+LITDEF	int GDE_WRITEERROR = 150503859;
+LITDEF	int GDE_NONASCII = 150503866;
+LITDEF	int GDE_CRYPTNOMM = 150503874;
+LITDEF	int GDE_JNLALLOCGROW = 150503883;
+LITDEF	int GDE_KEYFORBLK = 150503891;
+
+GBLDEF	err_ctl gdeerrors_ctl = {
+	248,
+	"GDE",
+	&gdeerrors[0],
+	58};

sr_i386/incr_link.c

@@ -16,7 +16,7 @@
 #include "gtm_string.h"
 #include <errno.h>
 
-#include "rtnhdr.h"
+#include <rtnhdr.h>
 #include "compiler.h"
 #include "urx.h"
 #include "objlabel.h"	/* needed for masscomp.h */

sr_i386/make_cimode.c

@@ -14,7 +14,7 @@
 #include "gtm_string.h"
 
 #include "error.h"
-#include "rtnhdr.h"
+#include <rtnhdr.h>
 #include "op.h"
 #include "i386.h"
 #include "inst_flush.h"

sr_i386/make_dmode.c

@@ -14,7 +14,7 @@
 #include "gtm_string.h"
 
 #include "error.h"
-#include "rtnhdr.h"
+#include <rtnhdr.h>
 #include "op.h"
 #include "i386.h"
 #include "inst_flush.h"

sr_i386/mval_def.si

@@ -1,6 +1,6 @@
 #################################################################
 #								#
-#	Copyright 2001, 2011 Fidelity Information Services, Inc	#
+#	Copyright 2001, 2012 Fidelity Information Services, Inc	#
 #								#
 #	This source code contains the intellectual property	#
 #	of its copyright holder(s), and is made available	#
@@ -95,6 +95,19 @@ top			=	8
         addl    $4,%esp
 	movl	%eax, \mval
 \label:
+.endm
+
+	.sbttl	mval_def.si    mv_force_defined_strict
+# ---------------------------------------
+#       mv_force_defined_strict(mval, label)
+# ---------------------------------------
+.macro  mv_force_defined_strict mval, label
+        testw   $(mval_m_str+mval_m_nm),mval_w_mvtype(\mval)
+        jne     \label
+	pushl   \mval
+        call    underr_strict
+        addl    $4,%esp
+\label:
 .endm
 
 	.sbttl	mval_def.si    mv_force_str

sr_i386/obj_file.c

@@ -16,7 +16,7 @@
 #include <errno.h>
 
 #include "compiler.h"
-#include "rtnhdr.h"
+#include <rtnhdr.h>
 #include "obj_gen.h"
 #include "cgp.h"
 #include "mdq.h"

sr_i386/op_forloop.s

@@ -1,6 +1,6 @@
 #################################################################
 #								#
-#	Copyright 2001, 2008 Fidelity Information Services, Inc	#
+#	Copyright 2001, 2012 Fidelity Information Services, Inc	#
 #								#
 #	This source code contains the intellectual property	#
 #	of its copyright holder(s), and is made available	#
@@ -53,7 +53,7 @@ ENTRY op_forloop
 	pushl	%esi
 	pushl	%ebx
 	movl	indx(%ebp),%esi
-	mv_force_defined %esi, l0
+	mv_force_defined_strict %esi, l0		# disregard NOUNDEF
 	movl	%esi, indx(%ebp)
 	mv_force_num %esi, l1
 	movl	indx(%ebp),%esi

sr_i386/opp_indsavglvn.s

@@ -1,6 +1,6 @@
 #################################################################
 #								#
-#	Copyright 2001, 2002 Sanchez Computer Associates, Inc.	#
+#	Copyright 2012 Fidelity Information Services, Inc	#
 #								#
 #	This source code contains the intellectual property	#
 #	of its copyright holder(s), and is made available	#
@@ -10,7 +10,7 @@
 #################################################################
 
 #	PAGE	,132
-	.title	op_isformal.s
+	.title	opp_indsavglvn.s
 
 #	.386
 #	.MODEL	FLAT, C
@@ -18,30 +18,22 @@
 .include "linkage.si"
 	.INCLUDE	"g_msf.si"
 
-	.sbttl	op_isformal
+	.sbttl	opp_indsavglvn
 #	PAGE	+
 	.DATA
-.extern	ERR_ACTLSTEXP
+.extern	frame_pointer 	# /* :DWORD */
-.extern	frame_pointer
 
 	.text
-.extern	rts_error
+.extern	op_indsavglvn
 
-# PUBLIC	op_isformal
+# PUBLIC	opp_indsavglvn
-ENTRY op_isformal
+ENTRY opp_indsavglvn  	# /* PROC */
-	movl	frame_pointer,%edx
+	putframe
-	movw	msf_typ_off(%edx),%ax
+	addl	$4,%esp		# /* burn return pc */
-	andw	$~SFT_EXTFUN,msf_typ_off(%edx)
+	call	op_indsavglvn
-	andw	$SFT_EXTFUN,%ax
+	addl	$12,%esp	# /* burn three passed-in args */
-	je	l1
+	getframe
 	ret
-
+# opp_indsavglvn ENDP
-l1:	putframe
-	pushl	ERR_ACTLSTEXP
-	pushl	$1
-	call	rts_error
-	addl	$8,%esp
-	ret
-# op_isformal ENDP
 
 # END

sr_i386/opp_indsavlvn.s

@@ -0,0 +1,39 @@
+#################################################################
+#								#
+#	Copyright 2012 Fidelity Information Services, Inc	#
+#								#
+#	This source code contains the intellectual property	#
+#	of its copyright holder(s), and is made available	#
+#	under a license.  If you do not know the terms of	#
+#	the license, please stop and do not read further.	#
+#								#
+#################################################################
+
+#	PAGE	,132
+	.title	opp_indsavlvn.s
+
+#	.386
+#	.MODEL	FLAT, C
+
+.include "linkage.si"
+	.INCLUDE	"g_msf.si"
+
+	.sbttl	opp_indsavlvn
+#	PAGE	+
+	.DATA
+.extern	frame_pointer 	# /* :DWORD */
+
+	.text
+.extern	op_indsavlvn
+
+# PUBLIC	opp_indsavlvn
+ENTRY opp_indsavlvn  	# /* PROC */
+	putframe
+	addl	$4,%esp		# /* burn return pc */
+	call	op_indsavlvn
+	addl	$8,%esp		# /* burn two passed-in args */
+	getframe
+	ret
+# opp_indsavlvn ENDP
+
+# END

sr_i386/opp_iretmval.s

@@ -1,6 +1,6 @@
 #################################################################
 #								#
-#	Copyright 2001, 2007 Fidelity Information Services, Inc	#
+#	Copyright 2001, 2012 Fidelity Information Services, Inc	#
 #								#
 #	This source code contains the intellectual property	#
 #	of its copyright holder(s), and is made available	#
@@ -29,9 +29,9 @@
 # PUBLIC	opp_iretmval
 ENTRY opp_iretmval 	# /* PROC */
 	putframe
-	addl	$4,%esp
+	addl	$4,%esp		# /* burn return pc */
 	call	op_iretmval
-	addl	$4,%esp
+	addl	$8,%esp		# /* burn two passed-in args */
 	getframe
 	ret
 # opp_iretmval ENDP

sr_i386/ttt.c

@@ -0,0 +1,693 @@
+/****************************************************************
+ *								*
+ *	Copyright 2001, 2013 Fidelity Information Services, Inc	*
+ *								*
+ *	This source code contains the intellectual property	*
+ *	of its copyright holder(s), and is made available	*
+ *	under a license.  If you do not know the terms of	*
+ *	the license, please stop and do not read further.	*
+ *								*
+ ****************************************************************/
+
+#include "mdef.h"
+#include "vxi.h"
+#include "vxt.h"
+#include "xfer_enum.h"
+LITDEF short ttt[4229] = {
+
+/*    0 */	0,0,0,0,324,3399,2842,548,
+/*    8 */	2220,2827,2857,1910,402,3349,2022,2973,
+/*   16 */	2099,2090,3582,3619,2063,2072,2138,2084,
+/*   24 */	2129,2108,2045,748,775,763,802,814,
+/*   32 */	826,844,886,904,922,943,972,1002,
+/*   40 */	1017,1032,1047,1065,1077,2943,2958,1149,
+/*   48 */	1182,1215,1254,1317,1368,1644,1659,1674,
+/*   56 */	1704,1743,1755,1779,1806,1827,1842,3414,
+/*   64 */	3436,0,0,0,0,563,0,504,
+/*   72 */	0,1896,0,2929,0,0,0,0,
+/*   80 */	0,0,356,414,2198,2204,2619,2646,
+/*   88 */	2664,2767,2705,2696,2782,3488,3572,2878,
+/*   96 */	0,2908,3039,3002,2987,3017,3363,3215,
+/*  104 */	3281,3494,3506,3521,3545,3554,3539,3530,
+/*  112 */	3314,3615,3628,3650,3687,3699,3720,3744,
+/*  120 */	3810,0,0,2815,2180,3091,4178,636,
+/*  128 */	4181,690,2676,3057,518,524,4184,2283,
+/*  136 */	2370,2270,471,2306,2390,2054,2328,2400,
+/*  144 */	4187,2165,2156,4191,1386,1404,4192,352,
+/*  152 */	348,3305,426,4196,4199,4202,2894,4205,
+/*  160 */	4208,4211,4214,4217,4220,3385,0,2791,
+/*  168 */	2459,2437,1623,2428,2216,2036,2742,1931,
+/*  176 */	715,2732,0,0,2235,3563,3591,1599,
+/*  184 */	3515,2318,1924,533,3711,1791,2147,1302,
+/*  192 */	339,3043,602,668,586,646,3675,1197,
+/*  200 */	1236,3643,2871,2174,2806,2885,618,1089,
+/*  208 */	2746,4223,2380,3762,3780,3795,495,2761,
+/*  216 */	3035,1869,3831,3822,1440,3377,577,1689,
+/*  224 */	1731,2343,4226,3448,2416,724,862,3074,
+/*  232 */	3603,3472,3458,3465,3454,700,957,2293,
+/*  240 */	1131,2257,1119,2117,1104,1164,2355,1569,
+/*  248 */	1512,1497,1551,1467,1479,1524,1452,1536,
+/*  256 */	1584,0,3335,0,981,990,3194,3260,
+/*  264 */	1818,3173,3239,2244,3867,3837,3843,3855,
+/*  272 */	3877,1341,1353,1275,1287,1329,3426,1719,
+/*  280 */	1854,3891,3906,3942,3969,3924,3101,3113,
+/*  288 */	3125,3137,2655,2670,1611,435,790,1422,
+/*  296 */	627,3149,3161,3954,3960,0,0,0,
+/*  304 */	0,3666,3981,3992,4004,4013,4027,4040,
+/*  312 */	4050,4067,4076,4085,4097,4109,4121,4136,
+/*  320 */	4148,0,0,4157,VXI_PUSHAB,VXT_VAL,0,VXI_PUSHAB,
+/*  328 */	VXT_VAL,2,VXI_PUSHAB,VXT_VAL,1,VXI_CALLS,VXT_LIT,3,
+/*  336 */	VXT_XFER,SIZEOF(char *) * (short int)xf_add,VXT_END,
+/*  339 */	VXT_IREPL,VXT_VAL,2,VXI_CALLS,VXT_VAL,1,VXT_XFER,SIZEOF(char *) * (short int)xf_bindparm,
+/*  347 */	VXT_END,
+/*  348 */	VXI_INCL,VXT_VAL,1,VXT_END,
+/*  352 */	VXI_CLRL,VXT_VAL,0,VXT_END,
+/*  356 */	VXI_JSB,VXT_XFER,SIZEOF(char *) * (short int)xf_break,VXT_END,
+/*  360 */	VXI_JSB,VXT_XFER,SIZEOF(char *) * (short int)xf_callb,VXI_BRB,VXT_JMP,1,VXT_END,
+/*  367 */	VXI_JSB,VXT_XFER,SIZEOF(char *) * (short int)xf_calll,VXI_JMP,VXT_JMP,1,VXT_END,
+/*  374 */	VXI_JSB,VXT_XFER,SIZEOF(char *) * (short int)xf_callw,VXI_BRW,VXT_JMP,1,VXT_END,
+/*  381 */	VXI_JSB,VXT_XFER,SIZEOF(char *) * (short int)xf_callspb,VXI_BRB,VXT_JMP,1,VXT_END,
+/*  388 */	VXI_JSB,VXT_XFER,SIZEOF(char *) * (short int)xf_callspl,VXI_JMP,VXT_JMP,1,VXT_END,
+/*  395 */	VXI_JSB,VXT_XFER,SIZEOF(char *) * (short int)xf_callspw,VXI_BRW,VXT_JMP,1,VXT_END,
+/*  402 */	VXT_IREPAB,VXT_VAL,2,VXI_PUSHAB,VXT_VAL,0,VXI_CALLS,VXT_VAL,
+/*  410 */	1,VXT_XFER,SIZEOF(char *) * (short int)xf_cat,VXT_END,
+/*  414 */	VXI_PUSHAB,VXT_VAL,2,VXI_PUSHAB,VXT_VAL,1,VXI_CALLS,VXT_LIT,
+/*  422 */	2,VXT_XFER,SIZEOF(char *) * (short int)xf_close,VXT_END,
+/*  426 */	VXI_BICB2,VXT_LIT,1,VXT_REG,0x5A,VXI_JSB,VXT_XFER,SIZEOF(char *) * (short int)xf_dt_false,
+/*  434 */	VXT_END,
+/*  435 */	VXI_PUSHAB,VXT_VAL,1,VXI_CALLS,VXT_LIT,1,VXT_XFER,SIZEOF(char *) * (short int)xf_clralsvars,
+/*  443 */	VXT_END,
+/*  444 */	VXI_TSTL,VXT_VAL,1,VXT_END,
+/*  448 */	VXI_MOVAB,VXT_VAL,1,VXT_REG,0x51,VXI_JSB,VXT_XFER,SIZEOF(char *) * (short int)xf_mval2bool,
+/*  456 */	VXT_END,
+/*  457 */	VXI_MOVAB,VXT_VAL,1,VXT_REG,0x51,VXI_JSB,VXT_XFER,SIZEOF(char *) * (short int)xf_mval2mint,
+/*  465 */	VXI_MOVL,VXT_REG,0x50,VXT_VAL,0,VXT_END,
+/*  471 */	VXI_PUSHL,VXT_VAL,2,VXI_PUSHAB,VXT_VAL,1,VXI_JSB,VXT_XFER,
+/*  479 */	SIZEOF(char *) * (short int)xf_commarg,VXT_END,
+/*  481 */	VXI_MOVAB,VXT_VAL,0,VXT_REG,0x50,VXI_MOVL,VXT_VAL,1,
+/*  489 */	VXT_REG,0x51,VXI_JSB,VXT_XFER,SIZEOF(char *) * (short int)xf_mint2mval,VXT_END,
+/*  495 */	VXI_MOVAB,VXT_VAL,1,VXT_REG,0x51,VXI_JSB,VXT_XFER,SIZEOF(char *) * (short int)xf_mval2num,
+/*  503 */	VXT_END,
+/*  504 */	VXI_MOVAB,VXT_VAL,1,VXT_REG,0x50,VXI_MOVAB,VXT_VAL,2,
+/*  512 */	VXT_REG,0x51,VXI_JSB,VXT_XFER,SIZEOF(char *) * (short int)xf_contain,VXT_END,
+/*  518 */	VXI_MOVL,VXT_REG,0x6C,VXT_ADDR,0,VXT_END,
+/*  524 */	VXI_MOVAB,VXT_VAL,0,VXT_REG,0x51,VXI_JSB,VXT_XFER,SIZEOF(char *) * (short int)xf_currtn,
+/*  532 */	VXT_END,
+/*  533 */	VXI_PUSHAB,VXT_VAL,0,VXI_PUSHAB,VXT_VAL,2,VXI_PUSHL,VXT_VAL,
+/*  541 */	1,VXI_CALLS,VXT_LIT,3,VXT_XFER,SIZEOF(char *) * (short int)xf_cvtparm,VXT_END,
+/*  548 */	VXI_PUSHAB,VXT_VAL,0,VXI_PUSHAB,VXT_VAL,2,VXI_PUSHAB,VXT_VAL,
+/*  556 */	1,VXI_CALLS,VXT_LIT,3,VXT_XFER,SIZEOF(char *) * (short int)xf_div,VXT_END,
+/*  563 */	VXI_MOVAB,VXT_VAL,2,VXT_REG,0x51,VXI_MOVAB,VXT_VAL,1,
+/*  571 */	VXT_REG,0x50,VXI_JSB,VXT_XFER,SIZEOF(char *) * (short int)xf_equ,VXT_END,
+/*  577 */	VXI_MOVAB,VXT_VAL,1,VXT_REG,0x50,VXI_JSB,VXT_XFER,SIZEOF(char *) * (short int)xf_equnul,
+/*  585 */	VXT_END,
+/*  586 */	VXT_IREPAB,VXT_VAL,4,VXI_PUSHL,VXT_VAL,3,VXI_PUSHL,VXT_VAL,
+/*  594 */	2,VXI_PUSHL,VXT_LIT,0,VXI_JSB,VXT_XFER,SIZEOF(char *) * (short int)xf_exfun,VXT_END,
+/*  602 */	VXT_IREPAB,VXT_VAL,4,VXI_PUSHL,VXT_VAL,3,VXI_PUSHL,VXT_VAL,
+/*  610 */	2,VXI_PUSHAB,VXT_VAL,0,VXI_JSB,VXT_XFER,SIZEOF(char *) * (short int)xf_exfun,VXT_END,
+/*  618 */	VXI_PUSHAB,VXT_VAL,1,VXI_CALLS,VXT_LIT,1,VXT_XFER,SIZEOF(char *) * (short int)xf_exfunret,
+/*  626 */	VXT_END,
+/*  627 */	VXI_PUSHAB,VXT_VAL,1,VXI_CALLS,VXT_LIT,1,VXT_XFER,SIZEOF(char *) * (short int)xf_exfunretals,
+/*  635 */	VXT_END,
+/*  636 */	VXI_PUSHAB,VXT_VAL,2,VXI_PUSHAB,VXT_VAL,1,VXI_JSB,VXT_XFER,
+/*  644 */	SIZEOF(char *) * (short int)xf_extcall,VXT_END,
+/*  646 */	VXT_IREPAB,VXT_VAL,5,VXI_PUSHL,VXT_VAL,4,VXI_PUSHL,VXT_VAL,
+/*  654 */	3,VXI_PUSHL,VXT_LIT,0,VXI_PUSHAB,VXT_VAL,2,VXI_PUSHAB,
+/*  662 */	VXT_VAL,1,VXI_JSB,VXT_XFER,SIZEOF(char *) * (short int)xf_extexfun,VXT_END,
+/*  668 */	VXT_IREPAB,VXT_VAL,5,VXI_PUSHL,VXT_VAL,4,VXI_PUSHL,VXT_VAL,
+/*  676 */	3,VXI_PUSHAB,VXT_VAL,0,VXI_PUSHAB,VXT_VAL,2,VXI_PUSHAB,
+/*  684 */	VXT_VAL,1,VXI_JSB,VXT_XFER,SIZEOF(char *) * (short int)xf_extexfun,VXT_END,
+/*  690 */	VXI_PUSHAB,VXT_VAL,2,VXI_PUSHAB,VXT_VAL,1,VXI_JSB,VXT_XFER,
+/*  698 */	SIZEOF(char *) * (short int)xf_extjmp,VXT_END,
+/*  700 */	VXI_PUSHAB,VXT_VAL,0,VXI_PUSHAB,VXT_VAL,2,VXI_PUSHAB,VXT_VAL,
+/*  708 */	1,VXI_CALLS,VXT_LIT,3,VXT_XFER,SIZEOF(char *) * (short int)xf_exp,VXT_END,
+/*  715 */	VXT_IREPL,VXT_VAL,2,VXI_CALLS,VXT_VAL,1,VXT_XFER,SIZEOF(char *) * (short int)xf_fetch,
+/*  723 */	VXT_END,
+/*  724 */	VXT_IREPAB,VXT_VAL,6,VXI_PUSHL,VXT_VAL,5,VXI_PUSHL,VXT_VAL,
+/*  732 */	4,VXI_PUSHAB,VXT_VAL,3,VXI_PUSHAB,VXT_VAL,2,VXI_PUSHL,
+/*  740 */	VXT_LIT,0,VXI_CALLS,VXT_VAL,1,VXT_XFER,SIZEOF(char *) * (short int)xf_fnfgncal,VXT_END,
+/*  748 */	VXI_PUSHAB,VXT_VAL,0,VXI_PUSHAB,VXT_VAL,1,VXI_PUSHL,VXT_VAL,
+/*  756 */	2,VXI_CALLS,VXT_LIT,3,VXT_XFER,SIZEOF(char *) * (short int)xf_fnascii,VXT_END,
+/*  763 */	VXT_IREPL,VXT_VAL,2,VXI_PUSHAB,VXT_VAL,0,VXI_CALLS,VXT_VAL,
+/*  771 */	1,VXT_XFER,SIZEOF(char *) * (short int)xf_fnchar,VXT_END,
+/*  775 */	VXI_PUSHAB,VXT_VAL,0,VXI_PUSHAB,VXT_VAL,1,VXI_PUSHL,VXT_VAL,
+/*  783 */	2,VXI_CALLS,VXT_LIT,3,VXT_XFER,SIZEOF(char *) * (short int)xf_fnzascii,VXT_END,
+/*  790 */	VXI_PUSHAB,VXT_VAL,0,VXI_PUSHAB,VXT_VAL,1,VXI_CALLS,VXT_LIT,
+/*  798 */	2,VXT_XFER,SIZEOF(char *) * (short int)xf_fnzahandle,VXT_END,
+/*  802 */	VXT_IREPL,VXT_VAL,2,VXI_PUSHAB,VXT_VAL,0,VXI_CALLS,VXT_VAL,
+/*  810 */	1,VXT_XFER,SIZEOF(char *) * (short int)xf_fnzchar,VXT_END,
+/*  814 */	VXI_PUSHAB,VXT_VAL,0,VXI_PUSHAB,VXT_VAL,1,VXI_CALLS,VXT_LIT,
+/*  822 */	2,VXT_XFER,SIZEOF(char *) * (short int)xf_fndata,VXT_END,
+/*  826 */	VXI_PUSHAB,VXT_VAL,0,VXI_PUSHAB,VXT_VAL,1,VXI_PUSHL,VXT_VAL,
+/*  834 */	2,VXI_PUSHL,VXT_VAL,3,VXI_CALLS,VXT_LIT,4,VXT_XFER,
+/*  842 */	SIZEOF(char *) * (short int)xf_fnextract,VXT_END,
+/*  844 */	VXI_PUSHAB,VXT_VAL,0,VXI_PUSHAB,VXT_VAL,1,VXI_PUSHL,VXT_VAL,
+/*  852 */	2,VXI_PUSHL,VXT_VAL,3,VXI_CALLS,VXT_LIT,4,VXT_XFER,
+/*  860 */	SIZEOF(char *) * (short int)xf_fnzextract,VXT_END,
+/*  862 */	VXT_IREPAB,VXT_VAL,6,VXI_PUSHL,VXT_VAL,5,VXI_PUSHL,VXT_VAL,
+/*  870 */	4,VXI_PUSHAB,VXT_VAL,3,VXI_PUSHAB,VXT_VAL,2,VXI_PUSHAB,
+/*  878 */	VXT_VAL,0,VXI_CALLS,VXT_VAL,1,VXT_XFER,SIZEOF(char *) * (short int)xf_fnfgncal,VXT_END,
+/*  886 */	VXI_PUSHAB,VXT_VAL,0,VXI_PUSHL,VXT_VAL,3,VXI_PUSHAB,VXT_VAL,
+/*  894 */	2,VXI_PUSHAB,VXT_VAL,1,VXI_CALLS,VXT_LIT,4,VXT_XFER,
+/*  902 */	SIZEOF(char *) * (short int)xf_fnfind,VXT_END,
+/*  904 */	VXI_PUSHAB,VXT_VAL,0,VXI_PUSHL,VXT_VAL,3,VXI_PUSHAB,VXT_VAL,
+/*  912 */	2,VXI_PUSHAB,VXT_VAL,1,VXI_CALLS,VXT_LIT,4,VXT_XFER,
+/*  920 */	SIZEOF(char *) * (short int)xf_fnzfind,VXT_END,
+/*  922 */	VXI_PUSHAB,VXT_VAL,0,VXI_PUSHL,VXT_VAL,4,VXI_PUSHL,VXT_VAL,
+/*  930 */	3,VXI_PUSHAB,VXT_VAL,2,VXI_PUSHAB,VXT_VAL,1,VXI_CALLS,
+/*  938 */	VXT_LIT,5,VXT_XFER,SIZEOF(char *) * (short int)xf_fnfnumber,VXT_END,
+/*  943 */	VXI_MOVAB,VXT_VAL,1,VXT_REG,0x51,VXI_MOVAB,VXT_VAL,0,
+/*  951 */	VXT_REG,0x50,VXI_JSB,VXT_XFER,SIZEOF(char *) * (short int)xf_fnget,VXT_END,
+/*  957 */	VXI_PUSHAB,VXT_VAL,0,VXI_PUSHAB,VXT_VAL,2,VXI_PUSHAB,VXT_VAL,
+/*  965 */	1,VXI_CALLS,VXT_LIT,3,VXT_XFER,SIZEOF(char *) * (short int)xf_fnget2,VXT_END,
+/*  972 */	VXI_PUSHAB,VXT_VAL,0,VXI_CALLS,VXT_LIT,1,VXT_XFER,SIZEOF(char *) * (short int)xf_fngvget,
+/*  980 */	VXT_END,
+/*  981 */	VXI_PUSHAB,VXT_VAL,0,VXI_CALLS,VXT_LIT,1,VXT_XFER,SIZEOF(char *) * (short int)xf_fngvget1,
+/*  989 */	VXT_END,
+/*  990 */	VXI_PUSHAB,VXT_VAL,0,VXI_PUSHAB,VXT_VAL,1,VXI_CALLS,VXT_LIT,
+/*  998 */	2,VXT_XFER,SIZEOF(char *) * (short int)xf_fnget1,VXT_END,
+/* 1002 */	VXI_PUSHAB,VXT_VAL,0,VXI_PUSHAB,VXT_VAL,2,VXI_PUSHAB,VXT_VAL,
+/* 1010 */	1,VXI_CALLS,VXT_LIT,3,VXT_XFER,SIZEOF(char *) * (short int)xf_fnincr,VXT_END,
+/* 1017 */	VXI_PUSHAB,VXT_VAL,0,VXI_PUSHL,VXT_VAL,2,VXI_PUSHAB,VXT_VAL,
+/* 1025 */	1,VXI_CALLS,VXT_LIT,3,VXT_XFER,SIZEOF(char *) * (short int)xf_fnj2,VXT_END,
+/* 1032 */	VXI_PUSHAB,VXT_VAL,0,VXI_PUSHL,VXT_VAL,2,VXI_PUSHAB,VXT_VAL,
+/* 1040 */	1,VXI_CALLS,VXT_LIT,3,VXT_XFER,SIZEOF(char *) * (short int)xf_fnzj2,VXT_END,
+/* 1047 */	VXI_PUSHAB,VXT_VAL,0,VXI_PUSHL,VXT_VAL,3,VXI_PUSHL,VXT_VAL,
+/* 1055 */	2,VXI_PUSHAB,VXT_VAL,1,VXI_CALLS,VXT_LIT,4,VXT_XFER,
+/* 1063 */	SIZEOF(char *) * (short int)xf_fnj3,VXT_END,
+/* 1065 */	VXI_PUSHAB,VXT_VAL,0,VXI_PUSHAB,VXT_VAL,1,VXI_CALLS,VXT_LIT,
+/* 1073 */	2,VXT_XFER,SIZEOF(char *) * (short int)xf_fnlength,VXT_END,
+/* 1077 */	VXI_PUSHAB,VXT_VAL,0,VXI_PUSHAB,VXT_VAL,1,VXI_CALLS,VXT_LIT,
+/* 1085 */	2,VXT_XFER,SIZEOF(char *) * (short int)xf_fnzlength,VXT_END,
+/* 1089 */	VXI_PUSHAB,VXT_VAL,0,VXI_PUSHL,VXT_VAL,2,VXI_PUSHAB,VXT_VAL,
+/* 1097 */	1,VXI_CALLS,VXT_LIT,3,VXT_XFER,SIZEOF(char *) * (short int)xf_fnlvname,VXT_END,
+/* 1104 */	VXI_PUSHAB,VXT_VAL,2,VXI_PUSHAB,VXT_VAL,0,VXI_PUSHAB,VXT_VAL,
+/* 1112 */	1,VXI_CALLS,VXT_LIT,3,VXT_XFER,SIZEOF(char *) * (short int)xf_fnlvnameo2,VXT_END,
+/* 1119 */	VXI_PUSHAB,VXT_VAL,0,VXI_PUSHAB,VXT_VAL,1,VXI_CALLS,VXT_LIT,
+/* 1127 */	2,VXT_XFER,SIZEOF(char *) * (short int)xf_fnlvprvname,VXT_END,
+/* 1131 */	VXT_IREPAB,VXT_VAL,4,VXI_PUSHAB,VXT_VAL,1,VXI_PUSHL,VXT_VAL,
+/* 1139 */	3,VXI_PUSHAB,VXT_VAL,0,VXI_CALLS,VXT_VAL,2,VXT_XFER,
+/* 1147 */	SIZEOF(char *) * (short int)xf_fnname,VXT_END,
+/* 1149 */	VXI_PUSHAB,VXT_VAL,0,VXI_PUSHAB,VXT_VAL,2,VXI_PUSHAB,VXT_VAL,
+/* 1157 */	1,VXI_CALLS,VXT_LIT,3,VXT_XFER,SIZEOF(char *) * (short int)xf_fnnext,VXT_END,
+/* 1164 */	VXI_PUSHAB,VXT_VAL,3,VXI_PUSHAB,VXT_VAL,0,VXI_PUSHAB,VXT_VAL,
+/* 1172 */	2,VXI_PUSHAB,VXT_VAL,1,VXI_CALLS,VXT_LIT,4,VXT_XFER,
+/* 1180 */	SIZEOF(char *) * (short int)xf_fno2,VXT_END,
+/* 1182 */	VXI_PUSHAB,VXT_VAL,0,VXI_PUSHAB,VXT_VAL,2,VXI_PUSHAB,VXT_VAL,
+/* 1190 */	1,VXI_CALLS,VXT_LIT,3,VXT_XFER,SIZEOF(char *) * (short int)xf_fnorder,VXT_END,
+/* 1197 */	VXI_PUSHAB,VXT_VAL,0,VXI_PUSHL,VXT_VAL,3,VXI_PUSHL,VXT_VAL,
+/* 1205 */	2,VXI_PUSHAB,VXT_VAL,1,VXI_CALLS,VXT_LIT,4,VXT_XFER,
+/* 1213 */	SIZEOF(char *) * (short int)xf_fnp1,VXT_END,
+/* 1215 */	VXI_PUSHAB,VXT_VAL,0,VXI_PUSHL,VXT_VAL,4,VXI_PUSHL,VXT_VAL,
+/* 1223 */	3,VXI_PUSHAB,VXT_VAL,2,VXI_PUSHAB,VXT_VAL,1,VXI_CALLS,
+/* 1231 */	VXT_LIT,5,VXT_XFER,SIZEOF(char *) * (short int)xf_fnpiece,VXT_END,
+/* 1236 */	VXI_PUSHAB,VXT_VAL,0,VXI_PUSHL,VXT_VAL,3,VXI_PUSHL,VXT_VAL,
+/* 1244 */	2,VXI_PUSHAB,VXT_VAL,1,VXI_CALLS,VXT_LIT,4,VXT_XFER,
+/* 1252 */	SIZEOF(char *) * (short int)xf_fnzp1,VXT_END,
+/* 1254 */	VXI_PUSHAB,VXT_VAL,0,VXI_PUSHL,VXT_VAL,4,VXI_PUSHL,VXT_VAL,
+/* 1262 */	3,VXI_PUSHAB,VXT_VAL,2,VXI_PUSHAB,VXT_VAL,1,VXI_CALLS,
+/* 1270 */	VXT_LIT,5,VXT_XFER,SIZEOF(char *) * (short int)xf_fnzpiece,VXT_END,
+/* 1275 */	VXI_PUSHAB,VXT_VAL,0,VXI_PUSHAB,VXT_VAL,1,VXI_CALLS,VXT_LIT,
+/* 1283 */	2,VXT_XFER,SIZEOF(char *) * (short int)xf_fnqlength,VXT_END,
+/* 1287 */	VXI_PUSHAB,VXT_VAL,0,VXI_PUSHL,VXT_VAL,2,VXI_PUSHAB,VXT_VAL,
+/* 1295 */	1,VXI_CALLS,VXT_LIT,3,VXT_XFER,SIZEOF(char *) * (short int)xf_fnqsubscript,VXT_END,
+/* 1302 */	VXT_IREPAB,VXT_VAL,3,VXI_PUSHAB,VXT_VAL,2,VXI_PUSHAB,VXT_VAL,
+/* 1310 */	0,VXI_CALLS,VXT_VAL,1,VXT_XFER,SIZEOF(char *) * (short int)xf_fnquery,VXT_END,
+/* 1317 */	VXI_PUSHAB,VXT_VAL,0,VXI_PUSHL,VXT_VAL,1,VXI_CALLS,VXT_LIT,
+/* 1325 */	2,VXT_XFER,SIZEOF(char *) * (short int)xf_fnrandom,VXT_END,
+/* 1329 */	VXI_PUSHAB,VXT_VAL,0,VXI_PUSHAB,VXT_VAL,1,VXI_CALLS,VXT_LIT,
+/* 1337 */	2,VXT_XFER,SIZEOF(char *) * (short int)xf_fnreverse,VXT_END,
+/* 1341 */	VXI_PUSHAB,VXT_VAL,0,VXI_PUSHL,VXT_VAL,1,VXI_CALLS,VXT_LIT,
+/* 1349 */	2,VXT_XFER,SIZEOF(char *) * (short int)xf_fnstack1,VXT_END,
+/* 1353 */	VXI_PUSHAB,VXT_VAL,0,VXI_PUSHAB,VXT_VAL,2,VXI_PUSHL,VXT_VAL,
+/* 1361 */	1,VXI_CALLS,VXT_LIT,3,VXT_XFER,SIZEOF(char *) * (short int)xf_fnstack2,VXT_END,
+/* 1368 */	VXI_PUSHAB,VXT_VAL,0,VXI_PUSHAB,VXT_VAL,3,VXI_PUSHL,VXT_VAL,
+/* 1376 */	2,VXI_PUSHAB,VXT_VAL,1,VXI_CALLS,VXT_LIT,4,VXT_XFER,
+/* 1384 */	SIZEOF(char *) * (short int)xf_fntext,VXT_END,
+/* 1386 */	VXI_PUSHAB,VXT_VAL,0,VXI_PUSHAB,VXT_VAL,3,VXI_PUSHAB,VXT_VAL,
+/* 1394 */	2,VXI_PUSHAB,VXT_VAL,1,VXI_CALLS,VXT_LIT,4,VXT_XFER,
+/* 1402 */	SIZEOF(char *) * (short int)xf_fntranslate,VXT_END,
+/* 1404 */	VXI_PUSHAB,VXT_VAL,0,VXI_PUSHAB,VXT_VAL,3,VXI_PUSHAB,VXT_VAL,
+/* 1412 */	2,VXI_PUSHAB,VXT_VAL,1,VXI_CALLS,VXT_LIT,4,VXT_XFER,
+/* 1420 */	SIZEOF(char *) * (short int)xf_fnztranslate,VXT_END,
+/* 1422 */	VXI_PUSHAB,VXT_VAL,0,VXI_PUSHAB,VXT_VAL,3,VXI_PUSHAB,VXT_VAL,
+/* 1430 */	2,VXI_PUSHAB,VXT_VAL,1,VXI_CALLS,VXT_LIT,4,VXT_XFER,
+/* 1438 */	SIZEOF(char *) * (short int)xf_fnztrigger,VXT_END,
+/* 1440 */	VXT_IREPAB,VXT_VAL,2,VXI_PUSHAB,VXT_VAL,0,VXI_CALLS,VXT_VAL,
+/* 1448 */	1,VXT_XFER,SIZEOF(char *) * (short int)xf_fnview,VXT_END,
+/* 1452 */	VXI_PUSHAB,VXT_VAL,2,VXI_PUSHAB,VXT_VAL,1,VXI_PUSHAB,VXT_VAL,
+/* 1460 */	0,VXI_CALLS,VXT_LIT,3,VXT_XFER,SIZEOF(char *) * (short int)xf_fnzbitand,VXT_END,
+/* 1467 */	VXI_PUSHAB,VXT_VAL,1,VXI_PUSHAB,VXT_VAL,0,VXI_CALLS,VXT_LIT,
+/* 1475 */	2,VXT_XFER,SIZEOF(char *) * (short int)xf_fnzbitcoun,VXT_END,
+/* 1479 */	VXI_PUSHL,VXT_VAL,3,VXI_PUSHL,VXT_VAL,2,VXI_PUSHAB,VXT_VAL,
+/* 1487 */	1,VXI_PUSHAB,VXT_VAL,0,VXI_CALLS,VXT_LIT,4,VXT_XFER,
+/* 1495 */	SIZEOF(char *) * (short int)xf_fnzbitfind,VXT_END,
+/* 1497 */	VXI_PUSHL,VXT_VAL,2,VXI_PUSHAB,VXT_VAL,1,VXI_PUSHAB,VXT_VAL,
+/* 1505 */	0,VXI_CALLS,VXT_LIT,3,VXT_XFER,SIZEOF(char *) * (short int)xf_fnzbitget,VXT_END,
+/* 1512 */	VXI_PUSHAB,VXT_VAL,1,VXI_PUSHAB,VXT_VAL,0,VXI_CALLS,VXT_LIT,
+/* 1520 */	2,VXT_XFER,SIZEOF(char *) * (short int)xf_fnzbitlen,VXT_END,
+/* 1524 */	VXI_PUSHAB,VXT_VAL,1,VXI_PUSHAB,VXT_VAL,0,VXI_CALLS,VXT_LIT,
+/* 1532 */	2,VXT_XFER,SIZEOF(char *) * (short int)xf_fnzbitnot,VXT_END,
+/* 1536 */	VXI_PUSHAB,VXT_VAL,2,VXI_PUSHAB,VXT_VAL,1,VXI_PUSHAB,VXT_VAL,
+/* 1544 */	0,VXI_CALLS,VXT_LIT,3,VXT_XFER,SIZEOF(char *) * (short int)xf_fnzbitor,VXT_END,
+/* 1551 */	VXI_PUSHL,VXT_VAL,3,VXI_PUSHL,VXT_VAL,2,VXI_PUSHAB,VXT_VAL,
+/* 1559 */	1,VXI_PUSHAB,VXT_VAL,0,VXI_CALLS,VXT_LIT,4,VXT_XFER,
+/* 1567 */	SIZEOF(char *) * (short int)xf_fnzbitset,VXT_END,
+/* 1569 */	VXI_PUSHL,VXT_VAL,2,VXI_PUSHL,VXT_VAL,1,VXI_PUSHAB,VXT_VAL,
+/* 1577 */	0,VXI_CALLS,VXT_LIT,3,VXT_XFER,SIZEOF(char *) * (short int)xf_fnzbitstr,VXT_END,
+/* 1584 */	VXI_PUSHAB,VXT_VAL,2,VXI_PUSHAB,VXT_VAL,1,VXI_PUSHAB,VXT_VAL,
+/* 1592 */	0,VXI_CALLS,VXT_LIT,3,VXT_XFER,SIZEOF(char *) * (short int)xf_fnzbitxor,VXT_END,
+/* 1599 */	VXT_IREPAB,VXT_VAL,2,VXI_PUSHAB,VXT_VAL,0,VXI_CALLS,VXT_VAL,
+/* 1607 */	1,VXT_XFER,SIZEOF(char *) * (short int)xf_fnzcall,VXT_END,
+/* 1611 */	VXI_PUSHAB,VXT_VAL,0,VXI_PUSHAB,VXT_VAL,1,VXI_CALLS,VXT_LIT,
+/* 1619 */	2,VXT_XFER,SIZEOF(char *) * (short int)xf_fnzdata,VXT_END,
+/* 1623 */	VXI_PUSHAB,VXT_VAL,0,VXI_PUSHAB,VXT_VAL,4,VXI_PUSHAB,VXT_VAL,
+/* 1631 */	3,VXI_PUSHAB,VXT_VAL,2,VXI_PUSHAB,VXT_VAL,1,VXI_CALLS,
+/* 1639 */	VXT_LIT,5,VXT_XFER,SIZEOF(char *) * (short int)xf_fnzdate,VXT_END,
+/* 1644 */	VXI_PUSHAB,VXT_VAL,0,VXI_PUSHAB,VXT_VAL,2,VXI_PUSHAB,VXT_VAL,
+/* 1652 */	1,VXI_CALLS,VXT_LIT,3,VXT_XFER,SIZEOF(char *) * (short int)xf_fnzfile,VXT_END,
+/* 1659 */	VXI_PUSHAB,VXT_VAL,0,VXI_PUSHAB,VXT_VAL,2,VXI_PUSHAB,VXT_VAL,
+/* 1667 */	1,VXI_CALLS,VXT_LIT,3,VXT_XFER,SIZEOF(char *) * (short int)xf_fngetdvi,VXT_END,
+/* 1674 */	VXI_PUSHAB,VXT_VAL,0,VXI_PUSHAB,VXT_VAL,2,VXI_PUSHL,VXT_VAL,
+/* 1682 */	1,VXI_CALLS,VXT_LIT,3,VXT_XFER,SIZEOF(char *) * (short int)xf_fngetjpi,VXT_END,
+/* 1689 */	VXI_PUSHAB,VXT_VAL,0,VXI_PUSHAB,VXT_VAL,2,VXI_PUSHL,VXT_VAL,
+/* 1697 */	1,VXI_CALLS,VXT_LIT,3,VXT_XFER,SIZEOF(char *) * (short int)xf_fngetlki,VXT_END,
+/* 1704 */	VXI_PUSHAB,VXT_VAL,0,VXI_PUSHAB,VXT_VAL,2,VXI_PUSHAB,VXT_VAL,
+/* 1712 */	1,VXI_CALLS,VXT_LIT,3,VXT_XFER,SIZEOF(char *) * (short int)xf_fngetsyi,VXT_END,
+/* 1719 */	VXI_PUSHAB,VXT_VAL,0,VXI_PUSHAB,VXT_VAL,1,VXI_CALLS,VXT_LIT,
+/* 1727 */	2,VXT_XFER,SIZEOF(char *) * (short int)xf_fnzjobexam,VXT_END,
+/* 1731 */	VXI_PUSHAB,VXT_VAL,0,VXI_PUSHL,VXT_VAL,1,VXI_CALLS,VXT_LIT,
+/* 1739 */	2,VXT_XFER,SIZEOF(char *) * (short int)xf_fnzlkid,VXT_END,
+/* 1743 */	VXI_PUSHAB,VXT_VAL,0,VXI_PUSHL,VXT_VAL,1,VXI_CALLS,VXT_LIT,
+/* 1751 */	2,VXT_XFER,SIZEOF(char *) * (short int)xf_fnzm,VXT_END,
+/* 1755 */	VXI_PUSHAB,VXT_VAL,0,VXI_PUSHAB,VXT_VAL,5,VXI_PUSHAB,VXT_VAL,
+/* 1763 */	4,VXI_PUSHAB,VXT_VAL,3,VXI_PUSHAB,VXT_VAL,2,VXI_PUSHAB,
+/* 1771 */	VXT_VAL,1,VXI_CALLS,VXT_LIT,6,VXT_XFER,SIZEOF(char *) * (short int)xf_fnzparse,VXT_END,
+/* 1779 */	VXI_PUSHAB,VXT_VAL,0,VXI_PUSHL,VXT_VAL,1,VXI_CALLS,VXT_LIT,
+/* 1787 */	2,VXT_XFER,SIZEOF(char *) * (short int)xf_fnzpid,VXT_END,
+/* 1791 */	VXI_PUSHAB,VXT_VAL,0,VXI_PUSHAB,VXT_VAL,2,VXI_PUSHAB,VXT_VAL,
+/* 1799 */	1,VXI_CALLS,VXT_LIT,3,VXT_XFER,SIZEOF(char *) * (short int)xf_fnzprevious,VXT_END,
+/* 1806 */	VXI_PUSHAB,VXT_VAL,0,VXI_PUSHAB,VXT_VAL,1,VXI_CALLS,VXT_LIT,
+/* 1814 */	2,VXT_XFER,SIZEOF(char *) * (short int)xf_fnzpriv,VXT_END,
+/* 1818 */	VXI_PUSHAB,VXT_VAL,0,VXI_CALLS,VXT_LIT,1,VXT_XFER,SIZEOF(char *) * (short int)xf_fnzqgblmod,
+/* 1826 */	VXT_END,
+/* 1827 */	VXI_PUSHAB,VXT_VAL,0,VXI_PUSHL,VXT_VAL,2,VXI_PUSHAB,VXT_VAL,
+/* 1835 */	1,VXI_CALLS,VXT_LIT,3,VXT_XFER,SIZEOF(char *) * (short int)xf_fnzsearch,VXT_END,
+/* 1842 */	VXI_PUSHAB,VXT_VAL,0,VXI_PUSHAB,VXT_VAL,1,VXI_CALLS,VXT_LIT,
+/* 1850 */	2,VXT_XFER,SIZEOF(char *) * (short int)xf_fnzsetprv,VXT_END,
+/* 1854 */	VXI_PUSHAB,VXT_VAL,0,VXI_PUSHL,VXT_VAL,2,VXI_PUSHL,VXT_VAL,
+/* 1862 */	1,VXI_CALLS,VXT_LIT,3,VXT_XFER,SIZEOF(char *) * (short int)xf_fnzsigproc,VXT_END,
+/* 1869 */	VXI_PUSHAB,VXT_VAL,0,VXI_PUSHAB,VXT_VAL,6,VXI_PUSHAB,VXT_VAL,
+/* 1877 */	5,VXI_PUSHAB,VXT_VAL,4,VXI_PUSHL,VXT_VAL,3,VXI_PUSHAB,
+/* 1885 */	VXT_VAL,2,VXI_PUSHAB,VXT_VAL,1,VXI_CALLS,VXT_LIT,7,
+/* 1893 */	VXT_XFER,SIZEOF(char *) * (short int)xf_fnztrnlnm,VXT_END,
+/* 1896 */	VXI_MOVAB,VXT_VAL,1,VXT_REG,0x50,VXI_MOVAB,VXT_VAL,2,
+/* 1904 */	VXT_REG,0x51,VXI_JSB,VXT_XFER,SIZEOF(char *) * (short int)xf_follow,VXT_END,
+/* 1910 */	VXI_MOVAB,VXT_VAL,0,VXT_REG,0x50,VXI_MOVAB,VXT_VAL,1,
+/* 1918 */	VXT_REG,0x51,VXI_JSB,VXT_XFER,SIZEOF(char *) * (short int)xf_forcenum,VXT_END,
+/* 1924 */	VXI_JSB,VXT_XFER,SIZEOF(char *) * (short int)xf_restartpc,VXI_JSB,VXT_XFER,SIZEOF(char *) * (short int)xf_forchk1,VXT_END,
+/* 1931 */	VXI_PUSHAB,VXT_VAL,3,VXI_PUSHAB,VXT_VAL,2,VXI_PUSHAB,VXT_VAL,
+/* 1939 */	1,VXI_JSB,VXT_XFER,SIZEOF(char *) * (short int)xf_forinit,VXT_END,
+/* 1944 */	VXI_JSB,VXT_XFER,SIZEOF(char *) * (short int)xf_forlcldob,VXI_BRB,VXT_JMP,1,VXT_END,
+/* 1951 */	VXI_JSB,VXT_XFER,SIZEOF(char *) * (short int)xf_forlcldol,VXI_JMP,VXT_JMP,1,VXT_END,
+/* 1958 */	VXI_JSB,VXT_XFER,SIZEOF(char *) * (short int)xf_forlcldow,VXI_BRW,VXT_JMP,1,VXT_END,
+/* 1965 */	VXI_JSB,VXT_XFER,SIZEOF(char *) * (short int)xf_restartpc,VXI_PUSHAB,VXT_JMP,1,VXI_PUSHAB,VXT_VAL,
+/* 1973 */	4,VXI_PUSHAB,VXT_VAL,3,VXI_PUSHAB,VXT_VAL,2,VXI_JSB,
+/* 1981 */	VXT_XFER,SIZEOF(char *) * (short int)xf_forloop,VXT_END,
+/* 1984 */	VXI_JSB,VXT_XFER,SIZEOF(char *) * (short int)xf_restartpc,VXI_PUSHAB,VXT_JMP,1,VXI_PUSHAB,VXT_VAL,
+/* 1992 */	4,VXI_PUSHAB,VXT_VAL,3,VXI_PUSHAB,VXT_VAL,2,VXI_JSB,
+/* 2000 */	VXT_XFER,SIZEOF(char *) * (short int)xf_forloop,VXT_END,
+/* 2003 */	VXI_JSB,VXT_XFER,SIZEOF(char *) * (short int)xf_restartpc,VXI_PUSHAB,VXT_JMP,1,VXI_PUSHAB,VXT_VAL,
+/* 2011 */	4,VXI_PUSHAB,VXT_VAL,3,VXI_PUSHAB,VXT_VAL,2,VXI_JSB,
+/* 2019 */	VXT_XFER,SIZEOF(char *) * (short int)xf_forloop,VXT_END,
+/* 2022 */	VXT_IREPAB,VXT_VAL,2,VXI_CALLS,VXT_VAL,1,VXT_XFER,SIZEOF(char *) * (short int)xf_getindx,
+/* 2030 */	VXI_MOVL,VXT_REG,0x50,VXT_ADDR,0,VXT_END,
+/* 2036 */	VXI_MOVAB,VXT_VAL,0,VXT_REG,0x51,VXI_JSB,VXT_XFER,SIZEOF(char *) * (short int)xf_gettruth,
+/* 2044 */	VXT_END,
+/* 2045 */	VXI_PUSHAB,VXT_VAL,0,VXI_CALLS,VXT_LIT,1,VXT_XFER,SIZEOF(char *) * (short int)xf_gvdata,
+/* 2053 */	VXT_END,
+/* 2054 */	VXT_IREPAB,VXT_VAL,2,VXI_CALLS,VXT_VAL,1,VXT_XFER,SIZEOF(char *) * (short int)xf_gvextnam,
+/* 2062 */	VXT_END,
+/* 2063 */	VXI_PUSHAB,VXT_VAL,0,VXI_CALLS,VXT_LIT,1,VXT_XFER,SIZEOF(char *) * (short int)xf_gvget,
+/* 2071 */	VXT_END,
+/* 2072 */	VXI_PUSHAB,VXT_VAL,0,VXI_PUSHAB,VXT_VAL,2,VXI_CALLS,VXT_LIT,
+/* 2080 */	2,VXT_XFER,SIZEOF(char *) * (short int)xf_gvincr,VXT_END,
+/* 2084 */	VXI_CALLS,VXT_LIT,0,VXT_XFER,SIZEOF(char *) * (short int)xf_gvkill,VXT_END,
+/* 2090 */	VXT_IREPAB,VXT_VAL,2,VXI_CALLS,VXT_VAL,1,VXT_XFER,SIZEOF(char *) * (short int)xf_gvnaked,
+/* 2098 */	VXT_END,
+/* 2099 */	VXT_IREPAB,VXT_VAL,2,VXI_CALLS,VXT_VAL,1,VXT_XFER,SIZEOF(char *) * (short int)xf_gvname,
+/* 2107 */	VXT_END,
+/* 2108 */	VXI_PUSHAB,VXT_VAL,0,VXI_CALLS,VXT_LIT,1,VXT_XFER,SIZEOF(char *) * (short int)xf_gvnext,
+/* 2116 */	VXT_END,
+/* 2117 */	VXI_PUSHAB,VXT_VAL,1,VXI_PUSHAB,VXT_VAL,0,VXI_CALLS,VXT_LIT,
+/* 2125 */	2,VXT_XFER,SIZEOF(char *) * (short int)xf_gvo2,VXT_END,
+/* 2129 */	VXI_PUSHAB,VXT_VAL,0,VXI_CALLS,VXT_LIT,1,VXT_XFER,SIZEOF(char *) * (short int)xf_gvorder,
+/* 2137 */	VXT_END,
+/* 2138 */	VXI_PUSHAB,VXT_VAL,1,VXI_CALLS,VXT_LIT,1,VXT_XFER,SIZEOF(char *) * (short int)xf_gvput,
+/* 2146 */	VXT_END,
+/* 2147 */	VXI_PUSHAB,VXT_VAL,0,VXI_CALLS,VXT_LIT,1,VXT_XFER,SIZEOF(char *) * (short int)xf_gvquery,
+/* 2155 */	VXT_END,
+/* 2156 */	VXI_PUSHAB,VXT_VAL,1,VXI_CALLS,VXT_LIT,1,VXT_XFER,SIZEOF(char *) * (short int)xf_gvrectarg,
+/* 2164 */	VXT_END,
+/* 2165 */	VXI_PUSHAB,VXT_VAL,0,VXI_CALLS,VXT_LIT,1,VXT_XFER,SIZEOF(char *) * (short int)xf_gvsavtarg,
+/* 2173 */	VXT_END,
+/* 2174 */	VXI_CALLS,VXT_LIT,0,VXT_XFER,SIZEOF(char *) * (short int)xf_gvzwithdraw,VXT_END,
+/* 2180 */	VXI_JSB,VXT_XFER,SIZEOF(char *) * (short int)xf_restartpc,VXT_IREPAB,VXT_VAL,4,VXI_PUSHL,VXT_VAL,
+/* 2188 */	3,VXI_PUSHL,VXT_VAL,2,VXI_CALLS,VXT_VAL,1,VXT_XFER,
+/* 2196 */	SIZEOF(char *) * (short int)xf_gvzwrite,VXT_END,
+/* 2198 */	VXI_CALLS,VXT_LIT,0,VXT_XFER,SIZEOF(char *) * (short int)xf_halt,VXT_END,
+/* 2204 */	VXI_JSB,VXT_XFER,SIZEOF(char *) * (short int)xf_restartpc,VXI_PUSHAB,VXT_VAL,1,VXI_CALLS,VXT_LIT,
+/* 2212 */	1,VXT_XFER,SIZEOF(char *) * (short int)xf_hang,VXT_END,
+/* 2216 */	VXI_JSB,VXT_XFER,SIZEOF(char *) * (short int)xf_hardret,VXT_END,
+/* 2220 */	VXI_PUSHAB,VXT_VAL,0,VXI_PUSHAB,VXT_VAL,2,VXI_PUSHAB,VXT_VAL,
+/* 2228 */	1,VXI_CALLS,VXT_LIT,3,VXT_XFER,SIZEOF(char *) * (short int)xf_idiv,VXT_END,
+/* 2235 */	VXI_PUSHAB,VXT_VAL,0,VXI_CALLS,VXT_LIT,1,VXT_XFER,SIZEOF(char *) * (short int)xf_igetsrc,
+/* 2243 */	VXT_END,
+/* 2244 */	VXI_PUSHAB,VXT_VAL,0,VXI_PUSHL,VXT_VAL,2,VXI_PUSHAB,VXT_VAL,
+/* 2252 */	1,VXI_JSB,VXT_XFER,SIZEOF(char *) * (short int)xf_inddevparms,VXT_END,
+/* 2257 */	VXI_PUSHAB,VXT_VAL,2,VXI_PUSHAB,VXT_VAL,1,VXI_PUSHAB,VXT_VAL,
+/* 2265 */	0,VXI_JSB,VXT_XFER,SIZEOF(char *) * (short int)xf_indfnname,VXT_END,
+/* 2270 */	VXI_PUSHAB,VXT_VAL,0,VXI_PUSHL,VXT_VAL,2,VXI_PUSHAB,VXT_VAL,
+/* 2278 */	1,VXI_JSB,VXT_XFER,SIZEOF(char *) * (short int)xf_indfun,VXT_END,
+/* 2283 */	VXI_PUSHAB,VXT_VAL,0,VXI_PUSHAB,VXT_VAL,1,VXI_JSB,VXT_XFER,
+/* 2291 */	SIZEOF(char *) * (short int)xf_indglvn,VXT_END,
+/* 2293 */	VXI_PUSHAB,VXT_VAL,1,VXI_PUSHAB,VXT_VAL,2,VXI_PUSHAB,VXT_VAL,
+/* 2301 */	0,VXI_JSB,VXT_XFER,SIZEOF(char *) * (short int)xf_indincr,VXT_END,
+/* 2306 */	VXI_PUSHAB,VXT_VAL,1,VXI_JSB,VXT_XFER,SIZEOF(char *) * (short int)xf_indlvadr,VXI_MOVL,VXT_REG,
+/* 2314 */	0x50,VXT_ADDR,0,VXT_END,
+/* 2318 */	VXI_PUSHAB,VXT_VAL,0,VXI_PUSHAB,VXT_VAL,1,VXI_JSB,VXT_XFER,
+/* 2326 */	SIZEOF(char *) * (short int)xf_indlvarg,VXT_END,
+/* 2328 */	VXI_PUSHAB,VXT_VAL,2,VXI_PUSHAB,VXT_VAL,1,VXI_PUSHAB,VXT_VAL,
+/* 2336 */	0,VXI_CALLS,VXT_LIT,3,VXT_XFER,SIZEOF(char *) * (short int)xf_indname,VXT_END,
+/* 2343 */	VXI_PUSHAB,VXT_VAL,1,VXI_JSB,VXT_XFER,SIZEOF(char *) * (short int)xf_indlvnamadr,VXI_MOVL,VXT_REG,
+/* 2351 */	0x50,VXT_ADDR,0,VXT_END,
+/* 2355 */	VXI_PUSHAB,VXT_VAL,2,VXI_PUSHAB,VXT_VAL,1,VXI_PUSHAB,VXT_VAL,
+/* 2363 */	0,VXI_CALLS,VXT_LIT,3,VXT_XFER,SIZEOF(char *) * (short int)xf_indo2,VXT_END,
+/* 2370 */	VXI_PUSHAB,VXT_VAL,0,VXI_PUSHAB,VXT_VAL,1,VXI_JSB,VXT_XFER,
+/* 2378 */	SIZEOF(char *) * (short int)xf_indpat,VXT_END,
+/* 2380 */	VXI_PUSHAB,VXT_VAL,2,VXI_PUSHAB,VXT_VAL,1,VXI_JSB,VXT_XFER,
+/* 2388 */	SIZEOF(char *) * (short int)xf_indrzshow,VXT_END,
+/* 2390 */	VXI_PUSHAB,VXT_VAL,2,VXI_PUSHAB,VXT_VAL,1,VXI_JSB,VXT_XFER,
+/* 2398 */	SIZEOF(char *) * (short int)xf_indset,VXT_END,
+/* 2400 */	VXI_PUSHAB,VXT_VAL,0,VXI_PUSHAB,VXT_VAL,3,VXI_PUSHL,VXT_VAL,
+/* 2408 */	2,VXI_PUSHAB,VXT_VAL,1,VXI_JSB,VXT_XFER,SIZEOF(char *) * (short int)xf_indtext,VXT_END,
+/* 2416 */	VXI_JSB,VXT_XFER,SIZEOF(char *) * (short int)xf_restartpc,VXT_IREPAB,VXT_VAL,2,VXI_CALLS,VXT_VAL,
+/* 2424 */	1,VXT_XFER,SIZEOF(char *) * (short int)xf_iocontrol,VXT_END,
+/* 2428 */	VXI_MOVAB,VXT_VAL,1,VXT_REG,0x51,VXI_JSB,VXT_XFER,SIZEOF(char *) * (short int)xf_iretmvad,
+/* 2436 */	VXT_END,
+/* 2437 */	VXI_PUSHAB,VXT_VAL,2,VXI_PUSHAB,VXT_VAL,1,VXI_JSB,VXT_XFER,
+/* 2445 */	SIZEOF(char *) * (short int)xf_iretmval,VXT_END,
+/* 2447 */	VXI_BRB,VXT_JMP,1,VXT_END,
+/* 2451 */	VXI_JMP,VXT_JMP,1,VXT_END,
+/* 2455 */	VXI_BRW,VXT_JMP,1,VXT_END,
+/* 2459 */	VXI_JMP,VXT_VAL,1,VXT_END,
+/* 2463 */	VXI_BEQL,VXT_JMP,1,VXT_END,
+/* 2467 */	VXI_BNEQ,VXT_LIT,6,VXI_JMP,VXT_JMP,1,VXT_END,
+/* 2474 */	VXI_BNEQ,VXT_LIT,3,VXI_BRW,VXT_JMP,1,VXT_END,
+/* 2481 */	VXI_BGEQ,VXT_JMP,1,VXT_END,
+/* 2485 */	VXI_BLSS,VXT_LIT,6,VXI_JMP,VXT_JMP,1,VXT_END,
+/* 2492 */	VXI_BLSS,VXT_LIT,3,VXI_BRW,VXT_JMP,1,VXT_END,
+/* 2499 */	VXI_BGTR,VXT_JMP,1,VXT_END,
+/* 2503 */	VXI_BLEQ,VXT_LIT,6,VXI_JMP,VXT_JMP,1,VXT_END,
+/* 2510 */	VXI_BLEQ,VXT_LIT,3,VXI_BRW,VXT_JMP,1,VXT_END,
+/* 2517 */	VXI_BLEQ,VXT_JMP,1,VXT_END,
+/* 2521 */	VXI_BGTR,VXT_LIT,6,VXI_JMP,VXT_JMP,1,VXT_END,
+/* 2528 */	VXI_BGTR,VXT_LIT,3,VXI_BRW,VXT_JMP,1,VXT_END,
+/* 2535 */	VXI_BLSS,VXT_JMP,1,VXT_END,
+/* 2539 */	VXI_BGEQ,VXT_LIT,6,VXI_JMP,VXT_JMP,1,VXT_END,
+/* 2546 */	VXI_BGEQ,VXT_LIT,3,VXI_BRW,VXT_JMP,1,VXT_END,
+/* 2553 */	VXI_BNEQ,VXT_JMP,1,VXT_END,
+/* 2557 */	VXI_BNEQ,VXT_LIT,6,VXI_JMP,VXT_JMP,1,VXT_END,
+/* 2564 */	VXI_BEQL,VXT_LIT,3,VXI_BRW,VXT_JMP,1,VXT_END,
+/* 2571 */	VXI_BLBC,VXT_REG,0x5A,VXT_JMP,1,VXT_END,
+/* 2577 */	VXI_BLBS,VXT_REG,0x5A,VXT_LIT,6,VXI_JMP,VXT_JMP,1,
+/* 2585 */	VXT_END,
+/* 2586 */	VXI_BLBS,VXT_REG,0x5A,VXT_LIT,3,VXI_BRW,VXT_JMP,1,
+/* 2594 */	VXT_END,
+/* 2595 */	VXI_BLBS,VXT_REG,0x5A,VXT_JMP,1,VXT_END,
+/* 2601 */	VXI_BLBC,VXT_REG,0x5A,VXT_LIT,6,VXI_JMP,VXT_JMP,1,
+/* 2609 */	VXT_END,
+/* 2610 */	VXI_BLBC,VXT_REG,0x5A,VXT_LIT,3,VXI_BRW,VXT_JMP,1,
+/* 2618 */	VXT_END,
+/* 2619 */	VXI_JSB,VXT_XFER,SIZEOF(char *) * (short int)xf_restartpc,VXT_IREPAB,VXT_VAL,7,VXI_PUSHL,VXT_VAL,
+/* 2627 */	6,VXI_PUSHAB,VXT_VAL,5,VXI_PUSHAB,VXT_VAL,4,VXI_PUSHL,
+/* 2635 */	VXT_VAL,3,VXI_PUSHAB,VXT_VAL,2,VXI_CALLS,VXT_VAL,1,
+/* 2643 */	VXT_XFER,SIZEOF(char *) * (short int)xf_job,VXT_END,
+/* 2646 */	VXI_PUSHAB,VXT_VAL,1,VXI_CALLS,VXT_LIT,1,VXT_XFER,SIZEOF(char *) * (short int)xf_kill,
+/* 2654 */	VXT_END,
+/* 2655 */	VXI_PUSHL,VXT_VAL,1,VXI_CALLS,VXT_LIT,1,VXT_XFER,SIZEOF(char *) * (short int)xf_killalias,
+/* 2663 */	VXT_END,
+/* 2664 */	VXI_CALLS,VXT_LIT,0,VXT_XFER,SIZEOF(char *) * (short int)xf_killall,VXT_END,
+/* 2670 */	VXI_CALLS,VXT_LIT,0,VXT_XFER,SIZEOF(char *) * (short int)xf_killaliasall,VXT_END,
+/* 2676 */	VXI_PUSHL,VXT_VAL,2,VXI_PUSHAB,VXT_VAL,1,VXI_PUSHAB,VXT_VAL,
+/* 2684 */	3,VXI_CALLS,VXT_LIT,3,VXT_XFER,SIZEOF(char *) * (short int)xf_labaddr,VXI_MOVL,VXT_REG,
+/* 2692 */	0x50,VXT_ADDR,0,VXT_END,
+/* 2696 */	VXI_PUSHL,VXT_VAL,1,VXI_CALLS,VXT_LIT,1,VXT_XFER,SIZEOF(char *) * (short int)xf_lckdecr,
+/* 2704 */	VXT_END,
+/* 2705 */	VXI_PUSHL,VXT_VAL,1,VXI_CALLS,VXT_LIT,1,VXT_XFER,SIZEOF(char *) * (short int)xf_lckincr,
+/* 2713 */	VXT_END,
+/* 2714 */	VXI_MOVAB,VXT_JMP,1,VXT_ADDR,0,VXT_END,
+/* 2720 */	VXI_MOVAB,VXT_JMP,1,VXT_ADDR,0,VXT_END,
+/* 2726 */	VXI_MOVAB,VXT_JMP,1,VXT_ADDR,0,VXT_END,
+/* 2732 */	VXT_IREPL,VXT_VAL,2,VXI_PUSHL,VXT_VAL,1,VXI_JSB,VXT_XFER,
+/* 2740 */	SIZEOF(char *) * (short int)xf_linefetch,VXT_END,
+/* 2742 */	VXI_JSB,VXT_XFER,SIZEOF(char *) * (short int)xf_linestart,VXT_END,
+/* 2746 */	VXT_IREPAB,VXT_VAL,4,VXI_PUSHAB,VXT_VAL,3,VXI_PUSHAB,VXT_VAL,
+/* 2754 */	2,VXI_CALLS,VXT_VAL,1,VXT_XFER,SIZEOF(char *) * (short int)xf_lkname,VXT_END,
+/* 2761 */	VXI_CALLS,VXT_LIT,0,VXT_XFER,SIZEOF(char *) * (short int)xf_lkinit,VXT_END,
+/* 2767 */	VXT_IREPAB,VXT_VAL,4,VXI_PUSHAB,VXT_VAL,3,VXI_PUSHL,VXT_VAL,
+/* 2775 */	2,VXI_CALLS,VXT_VAL,1,VXT_XFER,SIZEOF(char *) * (short int)xf_lkname,VXT_END,
+/* 2782 */	VXI_PUSHL,VXT_VAL,1,VXI_CALLS,VXT_LIT,1,VXT_XFER,SIZEOF(char *) * (short int)xf_lock,
+/* 2790 */	VXT_END,
+/* 2791 */	VXI_JSB,VXT_XFER,SIZEOF(char *) * (short int)xf_restartpc,VXT_IREPAB,VXT_VAL,3,VXI_PUSHL,VXT_VAL,
+/* 2799 */	2,VXI_CALLS,VXT_VAL,1,VXT_XFER,SIZEOF(char *) * (short int)xf_lvpatwrite,VXT_END,
+/* 2806 */	VXI_PUSHAB,VXT_VAL,1,VXI_CALLS,VXT_LIT,1,VXT_XFER,SIZEOF(char *) * (short int)xf_lvzwithdraw,
+/* 2814 */	VXT_END,
+/* 2815 */	VXI_JSB,VXT_XFER,SIZEOF(char *) * (short int)xf_restartpc,VXT_IREPAB,VXT_VAL,2,VXI_CALLS,VXT_VAL,
+/* 2823 */	1,VXT_XFER,SIZEOF(char *) * (short int)xf_lvzwrite,VXT_END,
+/* 2827 */	VXI_PUSHAB,VXT_VAL,0,VXI_PUSHAB,VXT_VAL,2,VXI_PUSHAB,VXT_VAL,
+/* 2835 */	1,VXI_CALLS,VXT_LIT,3,VXT_XFER,SIZEOF(char *) * (short int)xf_flt_mod,VXT_END,
+/* 2842 */	VXI_PUSHAB,VXT_VAL,0,VXI_PUSHAB,VXT_VAL,2,VXI_PUSHAB,VXT_VAL,
+/* 2850 */	1,VXI_CALLS,VXT_LIT,3,VXT_XFER,SIZEOF(char *) * (short int)xf_mul,VXT_END,
+/* 2857 */	VXI_MOVAB,VXT_VAL,0,VXT_REG,0x50,VXI_MOVAB,VXT_VAL,1,
+/* 2865 */	VXT_REG,0x51,VXI_JSB,VXT_XFER,SIZEOF(char *) * (short int)xf_neg,VXT_END,
+/* 2871 */	VXI_PUSHL,VXT_VAL,1,VXI_JSB,VXT_XFER,SIZEOF(char *) * (short int)xf_newintrinsic,VXT_END,
+/* 2878 */	VXI_PUSHL,VXT_VAL,1,VXI_JSB,VXT_XFER,SIZEOF(char *) * (short int)xf_newvar,VXT_END,
+/* 2885 */	VXI_PUSHAB,VXT_VAL,0,VXI_CALLS,VXT_LIT,1,VXT_XFER,SIZEOF(char *) * (short int)xf_nullexp,
+/* 2893 */	VXT_END,
+/* 2894 */	VXI_MOVAB,VXT_VAL,1,VXT_REG,0x50,VXI_MOVAB,VXT_VAL,2,
+/* 2902 */	VXT_REG,0x51,VXI_JSB,VXT_XFER,SIZEOF(char *) * (short int)xf_numcmp,VXT_END,
+/* 2908 */	VXI_JSB,VXT_XFER,SIZEOF(char *) * (short int)xf_restartpc,VXI_PUSHAB,VXT_VAL,4,VXI_PUSHL,VXT_VAL,
+/* 2916 */	3,VXI_PUSHAB,VXT_VAL,2,VXI_PUSHAB,VXT_VAL,1,VXI_CALLS,
+/* 2924 */	VXT_LIT,4,VXT_XFER,SIZEOF(char *) * (short int)xf_open,VXT_END,
+/* 2929 */	VXI_MOVAB,VXT_VAL,1,VXT_REG,0x50,VXI_MOVAB,VXT_VAL,2,
+/* 2937 */	VXT_REG,0x51,VXI_JSB,VXT_XFER,SIZEOF(char *) * (short int)xf_pattern,VXT_END,
+/* 2943 */	VXI_PUSHAB,VXT_VAL,0,VXI_PUSHAB,VXT_VAL,2,VXI_PUSHAB,VXT_VAL,
+/* 2951 */	1,VXI_CALLS,VXT_LIT,3,VXT_XFER,SIZEOF(char *) * (short int)xf_fnpopulation,VXT_END,
+/* 2958 */	VXI_PUSHAB,VXT_VAL,0,VXI_PUSHAB,VXT_VAL,2,VXI_PUSHAB,VXT_VAL,
+/* 2966 */	1,VXI_CALLS,VXT_LIT,3,VXT_XFER,SIZEOF(char *) * (short int)xf_fnzpopulation,VXT_END,
+/* 2973 */	VXT_IREPAB,VXT_VAL,2,VXI_CALLS,VXT_VAL,1,VXT_XFER,SIZEOF(char *) * (short int)xf_putindx,
+/* 2981 */	VXI_MOVL,VXT_REG,0x50,VXT_ADDR,0,VXT_END,
+/* 2987 */	VXI_JSB,VXT_XFER,SIZEOF(char *) * (short int)xf_restartpc,VXI_PUSHL,VXT_VAL,1,VXI_PUSHAB,VXT_VAL,
+/* 2995 */	0,VXI_CALLS,VXT_LIT,2,VXT_XFER,SIZEOF(char *) * (short int)xf_rdone,VXT_END,
+/* 3002 */	VXI_JSB,VXT_XFER,SIZEOF(char *) * (short int)xf_restartpc,VXI_PUSHL,VXT_VAL,1,VXI_PUSHAB,VXT_VAL,
+/* 3010 */	0,VXI_CALLS,VXT_LIT,2,VXT_XFER,SIZEOF(char *) * (short int)xf_read,VXT_END,
+/* 3017 */	VXI_JSB,VXT_XFER,SIZEOF(char *) * (short int)xf_restartpc,VXI_PUSHL,VXT_VAL,2,VXI_PUSHL,VXT_VAL,
+/* 3025 */	1,VXI_PUSHAB,VXT_VAL,0,VXI_CALLS,VXT_LIT,3,VXT_XFER,
+/* 3033 */	SIZEOF(char *) * (short int)xf_readfl,VXT_END,
+/* 3035 */	VXI_JSB,VXT_XFER,SIZEOF(char *) * (short int)xf_restartpc,VXT_END,
+/* 3039 */	VXI_JSB,VXT_XFER,SIZEOF(char *) * (short int)xf_ret,VXT_END,
+/* 3043 */	VXI_MOVAB,VXT_VAL,1,VXT_REG,0x50,VXI_MOVL,VXT_VAL,2,
+/* 3051 */	VXT_REG,0x51,VXI_JSB,VXT_XFER,SIZEOF(char *) * (short int)xf_retarg,VXT_END,
+/* 3057 */	VXI_PUSHAB,VXT_VAL,2,VXI_PUSHAB,VXT_VAL,1,VXI_CALLS,VXT_LIT,
+/* 3065 */	2,VXT_XFER,SIZEOF(char *) * (short int)xf_rhdaddr,VXI_MOVL,VXT_REG,0x50,VXT_ADDR,0,
+/* 3073 */	VXT_END,
+/* 3074 */	VXI_PUSHL,VXT_LIT,0,VXI_PUSHAB,VXT_VAL,1,VXI_CALLS,VXT_LIT,
+/* 3082 */	2,VXT_XFER,SIZEOF(char *) * (short int)xf_rhdaddr,VXI_MOVL,VXT_REG,0x50,VXT_ADDR,0,
+/* 3090 */	VXT_END,
+/* 3091 */	VXI_PUSHL,VXT_VAL,2,VXI_PUSHL,VXT_VAL,1,VXI_JSB,VXT_XFER,
+/* 3099 */	SIZEOF(char *) * (short int)xf_rterror,VXT_END,
+/* 3101 */	VXI_PUSHL,VXT_VAL,1,VXI_PUSHAB,VXT_VAL,2,VXI_CALLS,VXT_LIT,
+/* 3109 */	2,VXT_XFER,SIZEOF(char *) * (short int)xf_setals2als,VXT_END,
+/* 3113 */	VXI_PUSHAB,VXT_VAL,1,VXI_PUSHAB,VXT_VAL,2,VXI_CALLS,VXT_LIT,
+/* 3121 */	2,VXT_XFER,SIZEOF(char *) * (short int)xf_setalsin2alsct,VXT_END,
+/* 3125 */	VXI_PUSHL,VXT_VAL,1,VXI_PUSHAB,VXT_VAL,2,VXI_CALLS,VXT_LIT,
+/* 3133 */	2,VXT_XFER,SIZEOF(char *) * (short int)xf_setalsctin2als,VXT_END,
+/* 3137 */	VXI_PUSHAB,VXT_VAL,1,VXI_PUSHAB,VXT_VAL,2,VXI_CALLS,VXT_LIT,
+/* 3145 */	2,VXT_XFER,SIZEOF(char *) * (short int)xf_setalsct2alsct,VXT_END,
+/* 3149 */	VXI_PUSHL,VXT_VAL,1,VXI_PUSHAB,VXT_VAL,2,VXI_CALLS,VXT_LIT,
+/* 3157 */	2,VXT_XFER,SIZEOF(char *) * (short int)xf_setfnretin2als,VXT_END,
+/* 3161 */	VXI_PUSHAB,VXT_VAL,1,VXI_PUSHAB,VXT_VAL,2,VXI_CALLS,VXT_LIT,
+/* 3169 */	2,VXT_XFER,SIZEOF(char *) * (short int)xf_setfnretin2alsct,VXT_END,
+/* 3173 */	VXI_PUSHAB,VXT_VAL,0,VXI_PUSHL,VXT_VAL,3,VXI_PUSHL,VXT_VAL,
+/* 3181 */	2,VXI_PUSHAB,VXT_VAL,4,VXI_PUSHAB,VXT_VAL,1,VXI_CALLS,
+/* 3189 */	VXT_LIT,5,VXT_XFER,SIZEOF(char *) * (short int)xf_setextract,VXT_END,
+/* 3194 */	VXI_PUSHAB,VXT_VAL,0,VXI_PUSHL,VXT_VAL,3,VXI_PUSHAB,VXT_VAL,
+/* 3202 */	4,VXI_PUSHL,VXT_VAL,2,VXI_PUSHAB,VXT_VAL,1,VXI_CALLS,
+/* 3210 */	VXT_LIT,5,VXT_XFER,SIZEOF(char *) * (short int)xf_setp1,VXT_END,
+/* 3215 */	VXI_PUSHAB,VXT_VAL,0,VXI_PUSHL,VXT_VAL,4,VXI_PUSHL,VXT_VAL,
+/* 3223 */	3,VXI_PUSHAB,VXT_VAL,5,VXI_PUSHAB,VXT_VAL,2,VXI_PUSHAB,
+/* 3231 */	VXT_VAL,1,VXI_CALLS,VXT_LIT,6,VXT_XFER,SIZEOF(char *) * (short int)xf_setpiece,VXT_END,
+/* 3239 */	VXI_PUSHAB,VXT_VAL,0,VXI_PUSHL,VXT_VAL,3,VXI_PUSHL,VXT_VAL,
+/* 3247 */	2,VXI_PUSHAB,VXT_VAL,4,VXI_PUSHAB,VXT_VAL,1,VXI_CALLS,
+/* 3255 */	VXT_LIT,5,VXT_XFER,SIZEOF(char *) * (short int)xf_setzextract,VXT_END,
+/* 3260 */	VXI_PUSHAB,VXT_VAL,0,VXI_PUSHL,VXT_VAL,3,VXI_PUSHAB,VXT_VAL,
+/* 3268 */	4,VXI_PUSHL,VXT_VAL,2,VXI_PUSHAB,VXT_VAL,1,VXI_CALLS,
+/* 3276 */	VXT_LIT,5,VXT_XFER,SIZEOF(char *) * (short int)xf_setzp1,VXT_END,
+/* 3281 */	VXI_PUSHAB,VXT_VAL,0,VXI_PUSHL,VXT_VAL,4,VXI_PUSHL,VXT_VAL,
+/* 3289 */	3,VXI_PUSHAB,VXT_VAL,5,VXI_PUSHAB,VXT_VAL,2,VXI_PUSHAB,
+/* 3297 */	VXT_VAL,1,VXI_CALLS,VXT_LIT,6,VXT_XFER,SIZEOF(char *) * (short int)xf_setzpiece,VXT_END,
+/* 3305 */	VXI_BISB2,VXT_LIT,1,VXT_REG,0x5A,VXI_JSB,VXT_XFER,SIZEOF(char *) * (short int)xf_dt_true,
+/* 3313 */	VXT_END,
+/* 3314 */	VXI_PUSHL,VXT_VAL,5,VXI_PUSHAB,VXT_VAL,4,VXI_PUSHL,VXT_VAL,
+/* 3322 */	2,VXI_PUSHAB,VXT_VAL,1,VXI_PUSHAB,VXT_VAL,3,VXI_CALLS,
+/* 3330 */	VXT_LIT,5,VXT_XFER,SIZEOF(char *) * (short int)xf_setzbrk,VXT_END,
+/* 3335 */	VXI_MOVAB,VXT_VAL,1,VXT_REG,0x50,VXI_MOVAB,VXT_VAL,2,
+/* 3343 */	VXT_REG,0x51,VXI_JSB,VXT_XFER,SIZEOF(char *) * (short int)xf_sorts_after,VXT_END,
+/* 3349 */	VXT_IREPAB,VXT_VAL,2,VXI_CALLS,VXT_VAL,1,VXT_XFER,SIZEOF(char *) * (short int)xf_srchindx,
+/* 3357 */	VXI_MOVL,VXT_REG,0x50,VXT_ADDR,0,VXT_END,
+/* 3363 */	VXI_MOVAB,VXT_VAL,2,VXT_REG,0x51,VXI_MOVAB,VXT_VAL,1,
+/* 3371 */	VXT_REG,0x50,VXI_JSB,VXT_XFER,SIZEOF(char *) * (short int)xf_sto,VXT_END,
+/* 3377 */	VXI_MOVC3,VXT_LIT,16,VXT_VAL,2,VXT_VAL,1,VXT_END,
+/* 3385 */	VXI_MOVAB,VXT_VAL,1,VXT_REG,0x51,VXI_MOVAB,VXT_VAL,0,
+/* 3393 */	VXT_REG,0x50,VXI_JSB,VXT_XFER,SIZEOF(char *) * (short int)xf_sto,VXT_END,
+/* 3399 */	VXI_PUSHAB,VXT_VAL,0,VXI_PUSHAB,VXT_VAL,2,VXI_PUSHAB,VXT_VAL,
+/* 3407 */	1,VXI_CALLS,VXT_LIT,3,VXT_XFER,SIZEOF(char *) * (short int)xf_sub,VXT_END,
+/* 3414 */	VXI_PUSHAB,VXT_VAL,0,VXI_PUSHL,VXT_VAL,1,VXI_CALLS,VXT_LIT,
+/* 3422 */	2,VXT_XFER,SIZEOF(char *) * (short int)xf_svget,VXT_END,
+/* 3426 */	VXI_PUSHAB,VXT_VAL,2,VXI_PUSHL,VXT_VAL,1,VXI_JSB,VXT_XFER,
+/* 3434 */	SIZEOF(char *) * (short int)xf_psvput,VXT_END,
+/* 3436 */	VXI_PUSHAB,VXT_VAL,2,VXI_PUSHL,VXT_VAL,1,VXI_CALLS,VXT_LIT,
+/* 3444 */	2,VXT_XFER,SIZEOF(char *) * (short int)xf_svput,VXT_END,
+/* 3448 */	VXI_MOVL,VXT_REG,0x50,VXT_REG,0x5A,VXT_END,
+/* 3454 */	VXI_JSB,VXT_XFER,SIZEOF(char *) * (short int)xf_tcommit,VXT_END,
+/* 3458 */	VXI_PUSHL,VXT_VAL,1,VXI_JSB,VXT_XFER,SIZEOF(char *) * (short int)xf_trollback,VXT_END,
+/* 3465 */	VXI_PUSHL,VXT_VAL,1,VXI_JSB,VXT_XFER,SIZEOF(char *) * (short int)xf_trestart,VXT_END,
+/* 3472 */	VXT_IREPAB,VXT_VAL,4,VXI_PUSHL,VXT_VAL,3,VXI_PUSHAB,VXT_VAL,
+/* 3480 */	2,VXI_PUSHL,VXT_VAL,1,VXI_JSB,VXT_XFER,SIZEOF(char *) * (short int)xf_tstart,VXT_END,
+/* 3488 */	VXI_CALLS,VXT_LIT,0,VXT_XFER,SIZEOF(char *) * (short int)xf_unlock,VXT_END,
+/* 3494 */	VXI_PUSHAB,VXT_VAL,2,VXI_PUSHAB,VXT_VAL,1,VXI_CALLS,VXT_LIT,
+/* 3502 */	2,VXT_XFER,SIZEOF(char *) * (short int)xf_use,VXT_END,
+/* 3506 */	VXT_IREPAB,VXT_VAL,2,VXI_CALLS,VXT_VAL,1,VXT_XFER,SIZEOF(char *) * (short int)xf_view,
+/* 3514 */	VXT_END,
+/* 3515 */	VXI_CMPL,VXT_VAL,1,VXT_VAL,2,VXT_END,
+/* 3521 */	VXI_PUSHAB,VXT_VAL,1,VXI_CALLS,VXT_LIT,1,VXT_XFER,SIZEOF(char *) * (short int)xf_write,
+/* 3529 */	VXT_END,
+/* 3530 */	VXI_PUSHL,VXT_VAL,1,VXI_CALLS,VXT_LIT,1,VXT_XFER,SIZEOF(char *) * (short int)xf_wteol,
+/* 3538 */	VXT_END,
+/* 3539 */	VXI_CALLS,VXT_LIT,0,VXT_XFER,SIZEOF(char *) * (short int)xf_wtff,VXT_END,
+/* 3545 */	VXI_PUSHL,VXT_VAL,1,VXI_CALLS,VXT_LIT,1,VXT_XFER,SIZEOF(char *) * (short int)xf_wtone,
+/* 3553 */	VXT_END,
+/* 3554 */	VXI_PUSHL,VXT_VAL,1,VXI_CALLS,VXT_LIT,1,VXT_XFER,SIZEOF(char *) * (short int)xf_wttab,
+/* 3562 */	VXT_END,
+/* 3563 */	VXT_IREPAB,VXT_VAL,2,VXI_CALLS,VXT_VAL,1,VXT_XFER,SIZEOF(char *) * (short int)xf_xkill,
+/* 3571 */	VXT_END,
+/* 3572 */	VXT_IREPAB,VXT_VAL,2,VXI_PUSHL,VXT_VAL,1,VXI_JSB,VXT_XFER,
+/* 3580 */	SIZEOF(char *) * (short int)xf_xnew,VXT_END,
+/* 3582 */	VXI_PUSHL,VXT_VAL,1,VXI_CALLS,VXT_LIT,1,VXT_XFER,SIZEOF(char *) * (short int)xf_zallocate,
+/* 3590 */	VXT_END,
+/* 3591 */	VXI_JSB,VXT_XFER,SIZEOF(char *) * (short int)xf_restartpc,VXI_PUSHAB,VXT_VAL,1,VXI_CALLS,VXT_LIT,
+/* 3599 */	1,VXT_XFER,SIZEOF(char *) * (short int)xf_zattach,VXT_END,
+/* 3603 */	VXI_PUSHL,VXT_VAL,2,VXI_PUSHAB,VXT_VAL,1,VXI_CALLS,VXT_LIT,
+/* 3611 */	2,VXT_XFER,SIZEOF(char *) * (short int)xf_zcompile,VXT_END,
+/* 3615 */	VXI_JSB,VXT_XFER,SIZEOF(char *) * (short int)xf_zcont,VXT_END,
+/* 3619 */	VXI_PUSHL,VXT_VAL,1,VXI_CALLS,VXT_LIT,1,VXT_XFER,SIZEOF(char *) * (short int)xf_zdeallocate,
+/* 3627 */	VXT_END,
+/* 3628 */	VXI_JSB,VXT_XFER,SIZEOF(char *) * (short int)xf_restartpc,VXI_PUSHAB,VXT_VAL,2,VXI_PUSHAB,VXT_VAL,
+/* 3636 */	1,VXI_CALLS,VXT_LIT,2,VXT_XFER,SIZEOF(char *) * (short int)xf_zedit,VXT_END,
+/* 3643 */	VXI_PUSHL,VXT_VAL,1,VXI_JSB,VXT_XFER,SIZEOF(char *) * (short int)xf_zg1,VXT_END,
+/* 3650 */	VXI_PUSHL,VXT_VAL,1,VXI_PUSHL,VXT_VAL,4,VXI_PUSHAB,VXT_VAL,
+/* 3658 */	3,VXI_PUSHAB,VXT_VAL,2,VXI_JSB,VXT_XFER,SIZEOF(char *) * (short int)xf_zgoto,VXT_END,
+/* 3666 */	VXI_PUSHAB,VXT_VAL,1,VXI_CALLS,VXT_LIT,1,VXT_XFER,SIZEOF(char *) * (short int)xf_zhalt,
+/* 3674 */	VXT_END,
+/* 3675 */	VXI_PUSHAB,VXT_VAL,2,VXI_PUSHAB,VXT_VAL,1,VXI_CALLS,VXT_LIT,
+/* 3683 */	2,VXT_XFER,SIZEOF(char *) * (short int)xf_zhelp,VXT_END,
+/* 3687 */	VXI_PUSHAB,VXT_VAL,2,VXI_PUSHAB,VXT_VAL,1,VXI_CALLS,VXT_LIT,
+/* 3695 */	2,VXT_XFER,SIZEOF(char *) * (short int)xf_zlink,VXT_END,
+/* 3699 */	VXT_IREPAB,VXT_VAL,3,VXI_PUSHL,VXT_VAL,2,VXI_CALLS,VXT_VAL,
+/* 3707 */	1,VXT_XFER,SIZEOF(char *) * (short int)xf_zmess,VXT_END,
+/* 3711 */	VXI_PUSHAB,VXT_VAL,0,VXI_CALLS,VXT_LIT,1,VXT_XFER,SIZEOF(char *) * (short int)xf_zprevious,
+/* 3719 */	VXT_END,
+/* 3720 */	VXI_JSB,VXT_XFER,SIZEOF(char *) * (short int)xf_restartpc,VXI_PUSHL,VXT_VAL,5,VXI_PUSHAB,VXT_VAL,
+/* 3728 */	4,VXI_PUSHL,VXT_VAL,3,VXI_PUSHAB,VXT_VAL,2,VXI_PUSHAB,
+/* 3736 */	VXT_VAL,1,VXI_CALLS,VXT_LIT,5,VXT_XFER,SIZEOF(char *) * (short int)xf_zprint,VXT_END,
+/* 3744 */	VXI_JSB,VXT_XFER,SIZEOF(char *) * (short int)xf_restartpc,VXI_PUSHL,VXT_LIT,0,VXI_PUSHL,VXT_VAL,
+/* 3752 */	2,VXI_PUSHAB,VXT_VAL,1,VXI_CALLS,VXT_LIT,3,VXT_XFER,
+/* 3760 */	SIZEOF(char *) * (short int)xf_zshow,VXT_END,
+/* 3762 */	VXI_JSB,VXT_XFER,SIZEOF(char *) * (short int)xf_restartpc,VXI_PUSHAB,VXT_VAL,3,VXI_PUSHL,VXT_VAL,
+/* 3770 */	2,VXI_PUSHAB,VXT_VAL,1,VXI_CALLS,VXT_LIT,3,VXT_XFER,
+/* 3778 */	SIZEOF(char *) * (short int)xf_zshow,VXT_END,
+/* 3780 */	VXI_PUSHL,VXT_LIT,0,VXI_PUSHL,VXT_VAL,1,VXI_CALLS,VXT_LIT,
+/* 3788 */	2,VXT_XFER,SIZEOF(char *) * (short int)xf_zstep,VXI_JSB,VXT_XFER,SIZEOF(char *) * (short int)xf_zcont,VXT_END,
+/* 3795 */	VXI_PUSHAB,VXT_VAL,2,VXI_PUSHL,VXT_VAL,1,VXI_CALLS,VXT_LIT,
+/* 3803 */	2,VXT_XFER,SIZEOF(char *) * (short int)xf_zstep,VXI_JSB,VXT_XFER,SIZEOF(char *) * (short int)xf_zcont,VXT_END,
+/* 3810 */	VXI_JSB,VXT_XFER,SIZEOF(char *) * (short int)xf_restartpc,VXI_PUSHAB,VXT_VAL,1,VXI_CALLS,VXT_LIT,
+/* 3818 */	1,VXT_XFER,SIZEOF(char *) * (short int)xf_zsystem,VXT_END,
+/* 3822 */	VXI_PUSHL,VXT_VAL,1,VXI_CALLS,VXT_LIT,1,VXT_XFER,SIZEOF(char *) * (short int)xf_ztcommit,
+/* 3830 */	VXT_END,
+/* 3831 */	VXI_CALLS,VXT_LIT,0,VXT_XFER,SIZEOF(char *) * (short int)xf_ztstart,VXT_END,
+/* 3837 */	VXI_CALLS,VXT_LIT,0,VXT_XFER,SIZEOF(char *) * (short int)xf_merge,VXT_END,
+/* 3843 */	VXI_PUSHL,VXT_LIT,0,VXI_PUSHL,VXT_VAL,1,VXI_CALLS,VXT_LIT,
+/* 3851 */	2,VXT_XFER,SIZEOF(char *) * (short int)xf_merge_arg,VXT_END,
+/* 3855 */	VXI_PUSHAB,VXT_VAL,2,VXI_PUSHL,VXT_VAL,1,VXI_CALLS,VXT_LIT,
+/* 3863 */	2,VXT_XFER,SIZEOF(char *) * (short int)xf_merge_arg,VXT_END,
+/* 3867 */	VXI_PUSHAB,VXT_VAL,1,VXI_PUSHAB,VXT_VAL,2,VXI_JSB,VXT_XFER,
+/* 3875 */	SIZEOF(char *) * (short int)xf_indmerge,VXT_END,
+/* 3877 */	VXT_IREPAB,VXT_VAL,2,VXI_CALLS,VXT_VAL,1,VXT_XFER,SIZEOF(char *) * (short int)xf_m_srchindx,
+/* 3885 */	VXI_MOVL,VXT_REG,0x50,VXT_ADDR,0,VXT_END,
+/* 3891 */	VXI_PUSHAB,VXT_VAL,0,VXI_PUSHAB,VXT_VAL,2,VXI_PUSHAB,VXT_VAL,
+/* 3899 */	1,VXI_CALLS,VXT_LIT,3,VXT_XFER,SIZEOF(char *) * (short int)xf_fnzconvert2,VXT_END,
+/* 3906 */	VXI_PUSHAB,VXT_VAL,0,VXI_PUSHAB,VXT_VAL,3,VXI_PUSHAB,VXT_VAL,
+/* 3914 */	2,VXI_PUSHAB,VXT_VAL,1,VXI_CALLS,VXT_LIT,4,VXT_XFER,
+/* 3922 */	SIZEOF(char *) * (short int)xf_fnzconvert3,VXT_END,
+/* 3924 */	VXI_PUSHAB,VXT_VAL,0,VXI_PUSHL,VXT_VAL,3,VXI_PUSHL,VXT_VAL,
+/* 3932 */	2,VXI_PUSHAB,VXT_VAL,1,VXI_CALLS,VXT_LIT,4,VXT_XFER,
+/* 3940 */	SIZEOF(char *) * (short int)xf_fnzsubstr,VXT_END,
+/* 3942 */	VXI_PUSHAB,VXT_VAL,0,VXI_PUSHAB,VXT_VAL,1,VXI_CALLS,VXT_LIT,
+/* 3950 */	2,VXT_XFER,SIZEOF(char *) * (short int)xf_fnzwidth,VXT_END,
+/* 3954 */	VXI_CALLS,VXT_LIT,0,VXT_XFER,SIZEOF(char *) * (short int)xf_ztrigger,VXT_END,
+/* 3960 */	VXI_PUSHL,VXT_VAL,1,VXI_CALLS,VXT_LIT,1,VXT_XFER,SIZEOF(char *) * (short int)xf_zwritesvn,
+/* 3968 */	VXT_END,
+/* 3969 */	VXI_PUSHAB,VXT_VAL,0,VXI_PUSHAB,VXT_VAL,1,VXI_CALLS,VXT_LIT,
+/* 3977 */	2,VXT_XFER,SIZEOF(char *) * (short int)xf_fnzwrite,VXT_END,
+/* 3981 */	VXI_CALLS,VXT_LIT,0,VXT_XFER,SIZEOF(char *) * (short int)xf_igetdst,VXI_MOVL,VXT_REG,0x50,
+/* 3989 */	VXT_ADDR,0,VXT_END,
+/* 3992 */	VXI_PUSHAB,VXT_VAL,0,VXI_PUSHAB,VXT_VAL,1,VXI_CALLS,VXT_LIT,
+/* 4000 */	2,VXT_XFER,SIZEOF(char *) * (short int)xf_indget1,VXT_END,
+/* 4004 */	VXI_PUSHAB,VXT_VAL,1,VXI_CALLS,VXT_LIT,1,VXT_XFER,SIZEOF(char *) * (short int)xf_glvnpop,
+/* 4012 */	VXT_END,
+/* 4013 */	VXI_PUSHL,VXT_VAL,1,VXI_CALLS,VXT_LIT,1,VXT_XFER,SIZEOF(char *) * (short int)xf_glvnslot,
+/* 4021 */	VXI_MOVL,VXT_REG,0x50,VXT_ADDR,0,VXT_END,
+/* 4027 */	VXI_PUSHL,VXT_VAL,3,VXI_PUSHAB,VXT_VAL,2,VXI_PUSHAB,VXT_VAL,
+/* 4035 */	1,VXI_JSB,VXT_XFER,SIZEOF(char *) * (short int)xf_indsavglvn,VXT_END,
+/* 4040 */	VXI_PUSHAB,VXT_VAL,2,VXI_PUSHAB,VXT_VAL,1,VXI_JSB,VXT_XFER,
+/* 4048 */	SIZEOF(char *) * (short int)xf_indsavlvn,VXT_END,
+/* 4050 */	VXI_PUSHL,VXT_VAL,2,VXI_PUSHAB,VXT_VAL,1,VXI_CALLS,VXT_LIT,
+/* 4058 */	2,VXT_XFER,SIZEOF(char *) * (short int)xf_rfrshlvn,VXI_MOVL,VXT_REG,0x50,VXT_ADDR,0,
+/* 4066 */	VXT_END,
+/* 4067 */	VXT_IREPAB,VXT_VAL,2,VXI_CALLS,VXT_VAL,1,VXT_XFER,SIZEOF(char *) * (short int)xf_savgvn,
+/* 4075 */	VXT_END,
+/* 4076 */	VXT_IREPAB,VXT_VAL,2,VXI_CALLS,VXT_VAL,1,VXT_XFER,SIZEOF(char *) * (short int)xf_savlvn,
+/* 4084 */	VXT_END,
+/* 4085 */	VXI_PUSHL,VXT_VAL,2,VXI_PUSHAB,VXT_VAL,1,VXI_CALLS,VXT_LIT,
+/* 4093 */	2,VXT_XFER,SIZEOF(char *) * (short int)xf_shareslot,VXT_END,
+/* 4097 */	VXI_PUSHAB,VXT_VAL,2,VXI_PUSHAB,VXT_VAL,1,VXI_CALLS,VXT_LIT,
+/* 4105 */	2,VXT_XFER,SIZEOF(char *) * (short int)xf_stoglvn,VXT_END,
+/* 4109 */	VXI_PUSHL,VXT_VAL,2,VXI_PUSHAB,VXT_VAL,1,VXI_CALLS,VXT_LIT,
+/* 4117 */	2,VXT_XFER,SIZEOF(char *) * (short int)xf_rfrshgvn,VXT_END,
+/* 4121 */	VXI_PUSHAB,VXT_VAL,2,VXI_PUSHAB,VXT_VAL,1,VXI_PUSHAB,VXT_VAL,
+/* 4129 */	0,VXI_CALLS,VXT_LIT,3,VXT_XFER,SIZEOF(char *) * (short int)xf_indfnname2,VXT_END,
+/* 4136 */	VXI_PUSHAB,VXT_VAL,1,VXI_PUSHAB,VXT_VAL,0,VXI_CALLS,VXT_LIT,
+/* 4144 */	2,VXT_XFER,SIZEOF(char *) * (short int)xf_indget2,VXT_END,
+/* 4148 */	VXI_PUSHAB,VXT_VAL,1,VXI_CALLS,VXT_LIT,1,VXT_XFER,SIZEOF(char *) * (short int)xf_indmerge2,
+/* 4156 */	VXT_END,
+/* 4157 */	VXI_PUSHAB,VXT_VAL,0,VXI_PUSHAB,VXT_VAL,4,VXI_PUSHL,VXT_VAL,
+/* 4165 */	3,VXI_PUSHL,VXT_VAL,2,VXI_PUSHAB,VXT_VAL,1,VXI_CALLS,
+/* 4173 */	VXT_LIT,5,VXT_XFER,SIZEOF(char *) * (short int)xf_fnzpeek,VXT_END,
+/* 4178 */	360,374,367,2447,2455,2451,2714,2726,
+/* 4186 */	2720,0,0,0,481,457,448,0,
+/* 4194 */	0,444,1965,2003,1984,2595,2610,2601,
+/* 4202 */	2571,2586,2577,2463,2474,2467,2553,2564,
+/* 4210 */	2557,2499,2510,2503,2517,2528,2521,2535,
+/* 4218 */	2546,2539,2481,2492,2485,1944,1958,1951,
+/* 4226 */	381,395,388};

sr_linux/CVS/Entries

@@ -0,0 +1,12 @@
+/arch.gtc/1.1.1.1/Wed May 16 14:01:21 2001//
+/caller_id.c/1.1/Fri Nov  2 03:00:15 2012//
+/genexport.csh/1.2/Fri Nov  2 03:00:15 2012//
+/gtm_env_sp.csh/1.9/Mon Jul  1 22:46:01 2013//
+/gtm_env_sp.mk/1.6/Fri Jan 11 04:43:23 2013//
+/gtm_getenv.c/1.1/Fri Nov  2 03:00:15 2012//
+/hugetlbfs_overrides.c/1.1/Fri Jan 11 05:31:39 2013//
+/hugetlbfs_overrides.h/1.1/Fri Jan 11 05:31:39 2013//
+/inst_flush.c/1.2/Fri Nov  2 03:00:15 2012//
+/platform.cmake/1.1/Fri Jan 11 05:31:39 2013//
+/release_name.h/1.6/Wed Oct 23 03:49:22 2013//
+D

sr_linux/CVS/Entries.Extra

@@ -0,0 +1,11 @@
+/arch.gtc////*////
+/caller_id.c////*////
+/genexport.csh////*////
+/gtm_env_sp.csh////*////
+/gtm_env_sp.mk////*////
+/gtm_getenv.c////*////
+/hugetlbfs_overrides.c////*////
+/hugetlbfs_overrides.h////*////
+/inst_flush.c////*////
+/platform.cmake////*////
+/release_name.h////*////

sr_linux/CVS/Repository

@@ -0,0 +1 @@
+gtm/sr_linux

sr_linux/CVS/Root

@@ -0,0 +1 @@
+:pserver:anonymous@fis-gtm.cvs.sourceforge.net:/cvsroot/fis-gtm

sr_linux/gtm_env_sp.csh

@@ -1,6 +1,6 @@
 #################################################################
 #								#
-#	Copyright 2001, 2012 Fidelity Information Services, Inc	#
+#	Copyright 2001, 2013 Fidelity Information Services, Inc	#
 #								#
 #	This source code contains the intellectual property	#
 #	of its copyright holder(s), and is made available	#
@@ -182,11 +182,12 @@ if ( $?gtm_version_change == "1" ) then
 	# -fno-defer-pop to prevent problems with assembly/generated code with optimization
 	# -fno-strict-aliasing since we don't comply with the rules
 	# -ffloat-store for consistent results avoiding rounding differences
+	# -fno-omit-frame-pointer so %rbp always gets set up (required by caller_id()). Default changed in gcc 4.6.
 	if ( "ia64" != $mach_type ) then
 		setenv	gt_cc_option_optimize	"-O2 -fno-defer-pop -fno-strict-aliasing -ffloat-store"
 		if ( "32" == $gt_build_type ) then
 			# applies to 32bit x86_64, ia32 and cygwin
-			setenv  gt_cc_option_optimize "$gt_cc_option_optimize -march=i686"
+			setenv  gt_cc_option_optimize "$gt_cc_option_optimize -fno-omit-frame-pointer -march=i686"
 		endif
 	endif
 	# -g	generate debugging information for dbx (no longer overrides -O)

sr_linux/gtm_env_sp.mk

@@ -65,25 +65,10 @@ gt_cc_option_nooptimize=
 gt_cc_option_optimize=-O2 -fno-defer-pop -fno-strict-aliasing -ffloat-store
 gt_cc_options_common+= -D_GNU_SOURCE -D_FILE_OFFSET_BITS=64 -D_XOPEN_SOURCE=600 -fsigned-char
 
-ifeq ($(gt_build_type),32)
-gt_cc_option_I=-I-
-endif
-
 ifeq ($(gt_machine_type), x86_64)
 ifeq ($(gt_build_type),32)
-# Do not lookup the source directory before include directories specified by -I.
-# gcc complains about -I- being obsolete, but using -iquote cause build errors for gcc and as - ABS 2008.12.09
-#
-# The -I- option is only needed for 32 bit builds on x86_64.  It provides a feature that is not present in
-# -iquote - namely -I- disables the ability to search the current directory for include files.  This is needed
-# when compiling something in sr_port which includes a file that is in both sr_port and the architecture specific
-# sr_386.  We don't want the sr_port version.  An example is sr_port/code_gen.c which includes emit_code.h.
-# emit_code.h is found in both sr_port and sr_i386.  Using -I- will find the sr_i386 version, but without it the
-# sr_port version is used. SLJ 2010.03.31
-
 # The /emul/ia32-linux/... directory doesn't exist on most machines, but when it's there we need it.  No problem
 # with always includeing it.
-
 gt_cc_option_I+= -I/emul/ia32-linux/usr/include/
 else
 gt_cc_option_I=

sr_linux/hugetlbfs_overrides.c

@@ -0,0 +1,112 @@
+/****************************************************************
+ *								*
+ *	Copyright 2012, 2013 Fidelity Information Services, Inc	*
+ *								*
+ *	This source code contains the intellectual property	*
+ *	of its copyright holder(s), and is made available	*
+ *	under a license.  If you do not know the terms of	*
+ *	the license, please stop and do not read further.	*
+ *								*
+ ****************************************************************/
+
+/*
+ * This file contains functions related to Linux HugeTLB support. Its functions rely
+ * on libhugetlbfs which allocates memory in Huge Pages.
+ * This library is Linux only and works only on (currently) x86, AMD64 and PowerPC
+ * Supported Huge Page functionality requires the following prerequisites:
+ *	Linux kernel support of Huge Pages
+ *	x86_64 or i386 architecture
+ *	libhugetlbfs.so being installed
+ *	Availability of Huge Pages through setting value to /proc/sys/vm/nr_hugepages or hugepages=<n> kernel parameter or
+ *		/proc/sys/vm/nr_overcommit_hugepages
+ *	In order to use shmget with Huge Pages, either the process gid should be in /proc/sys/vm/hugetlb_shm_group or the
+ *		process should have CAP_IPC_LOCK
+ *	In order to remap .text/.data/.bss sections, a file system of type hugetlbfs should be mounted
+ *	Appropriate environmental variables should be set (refer to libhugetlbfs documentation) to enable/disable Huge Pages
+ */
+#include "mdef.h"
+
+#include <dlfcn.h>
+#include "gtm_string.h"
+
+#include "get_page_size.h"
+#include "hugetlbfs_overrides.h"
+#undef shmget
+#include "send_msg.h"
+#include "wbox_test_init.h"
+#ifdef DEBUG
+#	define WBTEST_HUGETLB_DLSYM_ERROR "WBTEST_HUGETLB_DLSYM error"
+#endif
+
+GBLDEF long	gtm_os_hugepage_size = -1;	/* Default Huge Page size of OS. If huge pages are not supported or the
+ 	 	 	 	 	 	 * value doesn't fit into a *long* it will be equal to the OS page size
+ 	 	 	 	 	 	 */
+OS_PAGE_SIZE_DECLARE
+
+/* ptr to libhugetlbfs's overriden shmget. It uses Linux Huge Pages to back the shared segment if possible */
+STATICDEF int		(*p_shmget) (key_t, size_t, int) = NULL;
+/* returns default huge page size of the OS or -1 in case huge pages are not supported or their sizes doesn't
+ * fit into a long. Refer to libhugetlbfs for further info. */
+STATICDEF long		(*p_gethugepagesize) (void) = NULL;
+STATICDEF boolean_t	hugetlb_is_attempted = FALSE;
+/* all shmget declarations have already been MACROed to gtm_shmget in mdefsp.h so we need to declare the real
+ * one here */
+extern int 		shmget (key_t __key, size_t __size, int __shmflg);
+
+error_def(ERR_DLLNORTN);
+error_def(ERR_TEXT);
+
+/* A MACRO in mdefsp.h (LINUX_ONLY) replaces all shmget with this function */
+int gtm_shmget (key_t key, size_t size, int shmflg)
+{
+	assert(hugetlb_is_attempted);		/* libhugetlbfs_init must be called prior to this function */
+	return p_shmget(key, size, shmflg);
+}
+
+/*
+ * This function initializes libhugetlbfs if it's available. Upon dlopen() the initializing function of libhugetlbfs
+ * is called. If libhugetlbfs is available gtm_shmget uses its shmget. Otherwise it falls back to the native shmget.
+ * For malloc to use hugepages, it calls __morecore() hook if it needs more memory. In case libhugetlbfs is available
+ * and other Huge Page conditions are met, the libhugetlbfs assigns __morecore() to a version which backs them with
+ * hugepages during its initialization
+ * Consult libhugetlbfs documentation for a list of HugeTLB configuration environment variables.
+ */
+void libhugetlbfs_init(void)
+{
+	char 	*error = NULL;
+	void	*handle;
+
+	assert(!hugetlb_is_attempted);
+	handle = dlopen("libhugetlbfs.so", RTLD_NOW);
+	GTM_WHITE_BOX_TEST(WBTEST_HUGETLB_DLOPEN, handle, NULL);
+	if (NULL != handle)
+	{
+		/* C99 standard leaves casting from "void *" to a function pointer undefined. The assignment used
+		 * below is the POSIX.1-2003 (Technical Corrigendum 1) workaround; */
+		*(void **) (&p_shmget) = dlsym(handle, "shmget");
+		GTM_WHITE_BOX_TEST(WBTEST_HUGETLB_DLSYM, p_shmget, NULL);
+		if (NULL != p_shmget)		/* NULL value for shmget() necessarily means it was not found */
+		{
+			*(void **) (&p_gethugepagesize) = dlsym(handle, "gethugepagesize");
+			if (NULL != p_gethugepagesize)
+				gtm_os_hugepage_size = p_gethugepagesize();
+			else
+				error = dlerror();
+		} else
+			error = dlerror();
+		GTM_WHITE_BOX_TEST(WBTEST_HUGETLB_DLSYM, error, WBTEST_HUGETLB_DLSYM_ERROR);
+		if (error)
+		{
+			p_shmget = NULL;
+			send_msg(VARLSTCNT(8) ERR_DLLNORTN, 2, LEN_AND_LIT("shmget from libhugetlbfs.so"), ERR_TEXT, 2,
+					LEN_AND_STR(error));
+		}
+	}
+	if (NULL == p_shmget)
+		p_shmget = &shmget;			/* Fall back to using the native shmget */
+	get_page_size();
+	if (-1 == gtm_os_hugepage_size)
+		gtm_os_hugepage_size = OS_PAGE_SIZE;
+	assert(0 == (gtm_os_hugepage_size % OS_PAGE_SIZE));	/* huge pages sizes are multiples of page sizes */
+	hugetlb_is_attempted = TRUE;
+}

sr_linux/hugetlbfs_overrides.h

@@ -0,0 +1,25 @@
+/****************************************************************
+ *								*
+ *	Copyright 2012, 2013 Fidelity Information Services, Inc	*
+ *								*
+ *	This source code contains the intellectual property	*
+ *	of its copyright holder(s), and is made available	*
+ *	under a license.  If you do not know the terms of	*
+ *	the license, please stop and do not read further.	*
+ *								*
+ ****************************************************************/
+
+#ifndef HUGETLBFS_OVERRIDES_H_
+#define HUGETLBFS_OVERRIDES_H_
+
+#if defined(__linux__) && ( defined(__i386__) || defined(__x86_64__) )
+#	define HUGETLB_SUPPORTED	1
+#endif
+
+GBLREF long	gtm_os_hugepage_size;
+#define		OS_HUGEPAGE_SIZE gtm_os_hugepage_size
+
+extern int	gtm_shmget(key_t __key, size_t __size, int __shmflg);
+void 		libhugetlbfs_init(void);
+
+#endif /* HUGETLBFS_OVERRIDES_H_ */

sr_linux/platform.cmake

@@ -0,0 +1,59 @@
+#################################################################
+#								#
+#	Copyright 2013 Fidelity Information Services, Inc	#
+#								#
+#	This source code contains the intellectual property	#
+#	of its copyright holder(s), and is made available	#
+#	under a license.  If you do not know the terms of	#
+#	the license, please stop and do not read further.	#
+#								#
+#################################################################
+
+if("${CMAKE_SIZEOF_VOID_P}" EQUAL 4)
+  set(arch "x86")
+  set(bits 32)
+  set(FIND_LIBRARY_USE_LIB64_PATHS FALSE)
+else()
+  set(arch "x86_64")
+  set(bits 64)
+endif()
+
+# Platform directories
+list(APPEND gt_src_list sr_linux)
+if(${bits} EQUAL 32)
+  list(APPEND gt_src_list sr_i386 sr_x86_regs sr_unix_nsb)
+else()
+  list(APPEND gt_src_list sr_x86_64 sr_x86_regs)
+  set(gen_xfer_desc 1)
+endif()
+
+# Assembler
+set(CMAKE_INCLUDE_FLAG_ASM "-Wa,-I") # gcc -I does not make it to "as"
+
+# Compiler
+set(CMAKE_C_FLAGS
+  "${CMAKE_C_FLAGS} -ansi -fsigned-char -fPIC -Wmissing-prototypes -fno-omit-frame-pointer")
+
+set(CMAKE_C_FLAGS_RELEASE
+  "${CMAKE_C_FLAGS_RELEASE} -fno-defer-pop -fno-strict-aliasing -ffloat-store")
+
+add_definitions(
+  #-DNOLIBGTMSHR #gt_cc_option_DBTABLD=-DNOLIBGTMSHR
+  -D_GNU_SOURCE
+  -D_FILE_OFFSET_BITS=64
+  -D_XOPEN_SOURCE=600
+  -D_LARGEFILE64_SOURCE
+  )
+
+# Linker
+set(gtm_link  "-Wl,-u,gtm_filename_to_id -Wl,-u,gtm_zstatus -Wl,--version-script,\"${GTM_BINARY_DIR}/gtmexe_symbols.export\"")
+set(gtm_dep   "${GTM_BINARY_DIR}/gtmexe_symbols.export")
+
+set(libgtmshr_link "-Wl,-u,gtm_ci -Wl,-u,gtm_filename_to_id -Wl,--version-script,\"${GTM_BINARY_DIR}/gtmshr_symbols.export\"")
+set(libgtmshr_dep  "${GTM_BINARY_DIR}/gtmexe_symbols.export")
+
+if(${bits} EQUAL 32)
+  set(libmumpslibs "-lncurses -lm -ldl -lc -lpthread -lrt")
+else()
+  set(libmumpslibs "-lelf -lncurses -lm -ldl -lc -lpthread -lrt")
+endif()

sr_linux/release_name.h

@@ -10,15 +10,15 @@
  ****************************************************************/
 
 #ifdef __CYGWIN__
-#define GTM_RELEASE_NAME 	"GT.M V5.5-000 CYGWIN x86"
+#define GTM_RELEASE_NAME 	"GT.M V6.0-003 CYGWIN x86"
 #elif defined(__ia64)
-#define GTM_RELEASE_NAME 	"GT.M V5.5-000 Linux IA64"
+#define GTM_RELEASE_NAME 	"GT.M V6.0-003 Linux IA64"
 #elif defined(__x86_64__)
-#define GTM_RELEASE_NAME 	"GT.M V5.5-000 Linux x86_64"
+#define GTM_RELEASE_NAME 	"GT.M V6.0-003 Linux x86_64"
 #elif defined(__s390__)
-#define GTM_RELEASE_NAME 	"GT.M V5.5-000 Linux S390X"
+#define GTM_RELEASE_NAME 	"GT.M V6.0-003 Linux S390X"
 #else
-#define GTM_RELEASE_NAME 	"GT.M V5.5-000 Linux x86"
+#define GTM_RELEASE_NAME 	"GT.M V6.0-003 Linux x86"
 #endif
 #define GTM_PRODUCT 		"GT.M"
-#define GTM_VERSION		"V5.5"
+#define GTM_VERSION		"V6.0"

sr_port/CVS/Repository

@@ -0,0 +1 @@
+gtm/sr_port

sr_port/CVS/Root

@@ -0,0 +1 @@
+:pserver:anonymous@fis-gtm.cvs.sourceforge.net:/cvsroot/fis-gtm

sr_port/README.txt

@@ -0,0 +1,5 @@
+All software in this package is part of FIS GT.M (http://fis-gtm.com) which is Copyright 2012 Fidelity Information
+Services, Inc., and provided to you under the terms of a license. If there is a COPYING file included in this package,
+it contains the terms of the license under which the package is provided to you. If there is not a COPYING file in the
+package, you must ensure that your use of FIS GT.M complies with the license under which it is provided. If you are
+unsure as to the terms of your license, please consult with the entity that provided you with the package.

sr_port/act_in_gvt.c

@@ -19,7 +19,7 @@
 #include "collseq.h"
 #include "spec_type.h"
 #ifdef GTM_TRIGGER
-#include "rtnhdr.h"
+#include <rtnhdr.h>
 #include "gv_trigger.h"
 #endif
 

sr_port/actuallist.c

@@ -1,6 +1,6 @@
 /****************************************************************
  *								*
- *	Copyright 2001, 2011 Fidelity Information Services, Inc	*
+ *	Copyright 2001, 2013 Fidelity Information Services, Inc	*
  *								*
  *	This source code contains the intellectual property	*
  *	of its copyright holder(s), and is made available	*
@@ -13,15 +13,22 @@
 #include "compiler.h"
 #include "opcode.h"
 #include "toktyp.h"
+#include "mdq.h"
+#include "fullbool.h"
 #include "advancewindow.h"
+#include "show_source_line.h"
 
-error_def	(ERR_MAXACTARG);
+GBLREF	boolean_t	run_time;
-error_def	(ERR_NAMEEXPECTED);
+
-error_def	(ERR_COMMAORRPAREXP);
+error_def(ERR_COMMAORRPAREXP);
+error_def(ERR_MAXACTARG);
+error_def(ERR_NAMEEXPECTED);
+error_def(ERR_SIDEEFFECTEVAL);
 
 	int actuallist (oprtype *opr)
 {
-	int		mask, parmcount;
+	boolean_t	se_warn;
+	int		i, j, mask, parmcount;
 	oprtype		ot;
 	triple		*counttrip, *masktrip, *ref0, *ref1, *ref2;
 	DCL_THREADGBL_ACCESS;
@@ -96,6 +103,29 @@ error_def	(ERR_COMMAORRPAREXP);
 			}
 			ref0 = ref1;
 		}
+		if ((1 < parmcount) && (TREF(side_effect_base))[TREF(expr_depth)])
+		{	/* at least two arguments and at least one side effect - look for lvns needing protection */
+			assert(OLD_SE != TREF(side_effect_handling));
+			se_warn = (!run_time && (SE_WARN == TREF(side_effect_handling)));
+			for (i = 0, j = parmcount, ref0 = counttrip->operand[1].oprval.tref; --j;
+				ref0 = ref0->operand[1].oprval.tref)
+			{	/* no need to do the last argument - can't have a side effect after it */
+				assert(OC_PARAMETER == ref0->opcode);
+				assert((TRIP_REF == ref0->operand[0].oprclass) && (TRIP_REF == ref0->operand[1].oprclass));
+				if (!((1 << i++) & mask) && (OC_VAR == ref0->operand[0].oprval.tref->opcode))
+				{	/* can only protect pass-by-value (not pass-by-reference) */
+					ref1 = maketriple(OC_STOTEMP);
+					ref1->operand[0] = put_tref(ref0->operand[0].oprval.tref);
+					ref0->operand[0].oprval.tref = ref1;
+					dqins(ref0, exorder, ref1); 	/* NOTE:this violates information hiding */
+					if (se_warn)
+						ISSUE_SIDEEFFECTEVAL_WARNING(ref0->src.column);
+				}
+			}
+			/* the following asserts check we're getting only TRIP_REF or empty operands */
+			assert((NO_REF == ref0->operand[0].oprclass) || (TRIP_REF == ref0->operand[0].oprclass));
+			assert(((NO_REF == ref0->operand[0].oprclass) ? TRIP_REF : NO_REF) == ref0->operand[1].oprclass);
+		}
 	}
 	advancewindow();
 	masktrip->operand[0] = put_ilit(mask);

sr_port/adjust_frames.c

@@ -11,7 +11,7 @@
 
 #include "mdef.h"
 
-#include "rtnhdr.h"
+#include <rtnhdr.h>
 #include "stack_frame.h"
 
 GBLREF stack_frame	*frame_pointer;

sr_port/advancewindow.c

@@ -1,6 +1,6 @@
 /****************************************************************
  *								*
- *	Copyright 2001, 2011 Fidelity Information Services, Inc	*
+ *	Copyright 2001, 2013 Fidelity Information Services, Inc	*
  *								*
  *	This source code contains the intellectual property	*
  *	of its copyright holder(s), and is made available	*
@@ -52,7 +52,7 @@ static readonly unsigned char apos_ok[] =
 void advancewindow(void)
 {
 	unsigned char	*cp1, *cp2, *cp3, x;
-	char		*tmp, source_line_buff[MAX_SRCLINE + SIZEOF(ARROW)];
+	char		*tmp;
 	int		y, charlen;
 #	ifdef UNICODE_SUPPORTED
 	uint4		ch;
@@ -96,7 +96,7 @@ void advancewindow(void)
 				}
 				if (!run_time)
 				{
-					show_source_line(source_line_buff, SIZEOF(source_line_buff), TRUE);
+					show_source_line(TRUE);
 					dec_err(VARLSTCNT(1) ERR_LITNONGRAPH);
 				}
 			}
@@ -151,7 +151,7 @@ void advancewindow(void)
 		{
 			if (cp2 < cp3)
 				*cp2++ = x;
-			y = ctypetab[x = *++lexical_ptr];
+			y = ctypetab[x = *++lexical_ptr];			/* note assignment */
 			if ((TK_UPPER != y) && (TK_DIGIT != y) && (TK_LOWER != y))
 				break;
 		}
@@ -159,7 +159,7 @@ void advancewindow(void)
 		TREF(director_token) = TK_IDENT;
 		return;
 	case TK_PERIOD:
-		if (ctypetab[x = *(lexical_ptr + 1)] != TK_DIGIT)
+		if (ctypetab[x = *(lexical_ptr + 1)] != TK_DIGIT)		/* note assignment */
 			break;
 	case TK_DIGIT:
 		(TREF(director_mval)).str.addr = lexical_ptr;
@@ -186,14 +186,14 @@ void advancewindow(void)
 		}
 		return;
 	case TK_APOSTROPHE:
-		if (( x = *++lexical_ptr) >= 32)
+		if (32 <= (x = *++lexical_ptr))				/* note assignment */
 		{
 			x -= 32;
-			if (x < SIZEOF(apos_ok) / SIZEOF(unsigned char))
+			if (x < ARRAYSIZE(apos_ok))
 			{
 				if (y = apos_ok[x])
 				{
-					if (DEL < (x = *++lexical_ptr))
+					if (DEL < (x = *++lexical_ptr))		/* note assignment */
 					{
 						TREF(director_token) = TK_ERROR;
 						return;
@@ -210,6 +210,14 @@ void advancewindow(void)
 		}
 		TREF(director_token) = TK_APOSTROPHE;
 		return;
+	case TK_GREATER:
+	case TK_LESS:
+		if (TK_EQUAL == ctypetab[*(lexical_ptr + 1)])
+		{
+			++lexical_ptr;
+			y = ((TK_LESS == y) ? TK_NGREATER : TK_NLESS);
+		}
+		break;
 	case TK_SEMICOLON:
 		while (*++lexical_ptr)
 			;
@@ -217,7 +225,7 @@ void advancewindow(void)
 		TREF(director_token) = TK_EOL;
 		return;		/* if next character is terminator, avoid incrementing past it */
 	case TK_ASTERISK:
-		if (DEL < (x = *(lexical_ptr + 1)))
+		if (DEL < (x = *(lexical_ptr + 1)))				/* note assignment */
 		{
 			TREF(director_token) = TK_ERROR;
 			return;
@@ -229,7 +237,7 @@ void advancewindow(void)
 		}
 		break;
 	case TK_RBRACKET:
-		if ((x = *(lexical_ptr + 1)) > DEL)
+		if ((x = *(lexical_ptr + 1)) > DEL)				/* note assignment */
 		{
 			TREF(director_token) = TK_ERROR;
 			return;
@@ -240,6 +248,17 @@ void advancewindow(void)
 			y = TK_SORTS_AFTER;
 		}
 		break;
+	case TK_ATSIGN:
+		if (DEL < (x = *(lexical_ptr + 1)))				/* note assignment */
+		{
+			TREF(director_token) = TK_ERROR;
+			return;
+		}
+		if (TK_HASH == ctypetab[x])
+		{
+			lexical_ptr++;
+			y = TK_ATHASH;
+		}
 	default:
 		;
 	}

sr_port/alias_funcs.c

@@ -16,7 +16,7 @@
 
 #include <stddef.h>
 
-#include "rtnhdr.h"
+#include <rtnhdr.h>
 #include "stack_frame.h"
 #include "op.h"
 #include "stp_parms.h"

sr_port/alloc_reg.c

@@ -1,6 +1,6 @@
 /****************************************************************
  *								*
- *	Copyright 2001, 2012 Fidelity Information Services, Inc	*
+ *	Copyright 2001, 2013 Fidelity Information Services, Inc	*
  *								*
  *	This source code contains the intellectual property	*
  *	of its copyright holder(s), and is made available	*
@@ -23,8 +23,6 @@
 #include "alloc_reg.h"
 #include "cdbg_dump.h"
 
-#define MAX_TEMP_COUNT		128
-
 GBLDEF int4			sa_temps[VALUED_REF_TYPES];
 GBLDEF int4			sa_temps_offset[VALUED_REF_TYPES];
 
@@ -44,8 +42,12 @@ LITDEF int4 sa_class_sizes[VALUED_REF_TYPES] =
 };
 LITREF octabstruct 		oc_tab[];
 
+#define MAX_TEMP_COUNT		1024
+
 error_def(ERR_TMPSTOREMAX);
 
+STATICFNDCL void remove_backptr(triple *curtrip, oprtype *opnd, char (*tempcont)[MAX_TEMP_COUNT]);
+
 void alloc_reg(void)
 {
 	triple		*x, *y, *ref;
@@ -94,14 +96,22 @@ void alloc_reg(void)
 					COMPDBG(PRINTF("   ** Converting triple to NOOP (rsn 2) **\n"););
 					continue;	/* continue, because 'normal' NOOP continues from this switch */
 				}
+#				ifndef DEBUG
 				break;
+#				endif
 			case OC_LINEFETCH:
+#				ifdef DEBUG
+				for (c = temphigh[TVAL_REF]; 0 <= c; c--)
+					assert(0 == tempcont[TVAL_REF][c]);	/* check against leaking TVAL temps */
+				if (OC_LINESTART == opc)
+					break;
+#				endif
 			case OC_FETCH:
 				assert((TRIP_REF == x->operand[0].oprclass) && (OC_ILIT == x->operand[0].oprval.tref->opcode));
 				if (x->operand[0].oprval.tref->operand[0].oprval.ilit == mvmax)
 				{
 					x->operand[0].oprval.tref->operand[0].oprval.ilit = 0;
-					x->operand[1].oprclass = 0;
+					x->operand[1].oprclass = NO_REF;
 				}
 				break;
 			case OC_STO:
@@ -121,50 +131,24 @@ void alloc_reg(void)
 				    && (0 == x->operand[0].oprval.tref->operand[0].oprval.mlit->v.str.len))
 				{
 					x->operand[0] = x->operand[1];
-					x->operand[1].oprclass = 0;
+					x->operand[1].oprclass = NO_REF;
 					opc = x->opcode = OC_EQUNUL;
 				} else if ((TRIP_REF == x->operand[1].oprclass) && (OC_LIT == x->operand[1].oprval.tref->opcode)
 					   && (0 == x->operand[1].oprval.tref->operand[0].oprval.mlit->v.str.len))
 				{
-					x->operand[1].oprclass = 0;
+					x->operand[1].oprclass = NO_REF;
 					opc = x->opcode = OC_EQUNUL;
 				}
 				break;
 		}
-		for (j = x->operand, y = x; j < ARRAYTOP(y->operand); )
-		{
-			if (TRIP_REF == j->oprclass)
-			{
-				ref = j->oprval.tref;
-				if (OC_PARAMETER == ref->opcode)
-				{
-					y = ref;
-					j = y->operand;
-					continue;
-				}
-				if (r = ref->destination.oprclass)	/* Note assignment */
-				{
-					dqloop(&ref->backptr, que, b)
-					{
-						if (b->bpt == y)
-						{
-							dqdel(b, que);
-							break;
-						}
-					}
-					if ((ref->backptr.que.fl == &ref->backptr) && (TVAR_REF != r))
-						tempcont[r][j->oprval.tref->destination.oprval.temp] = 0;
-				}
-			}
-			j++;
-		}
 		if (OC_PASSTHRU == x->opcode)
 		{
 			COMPDBG(PRINTF(" *** OC_PASSTHRU opcode being NOOP'd\n"););
+			remove_backptr(x, &x->operand[0], tempcont);
 			x->opcode = OC_NOOP;
 			continue;
 		}
-		if (!(dest_type = x->destination.oprclass))	/* Note assignment */
+		if (NO_REF == (dest_type = x->destination.oprclass))	/* Note assignment */
 		{
 			oct = oc_tab[opc].octype;
 			if ((oct & OCT_VALUE) && (x->backptr.que.fl != &x->backptr) && !(oct & OCT_CGSKIP))
@@ -175,7 +159,7 @@ void alloc_reg(void)
 				{
 					x->destination = y->operand[0];
 					y->opcode = OC_NOOP;
-					y->operand[0].oprclass = y->operand[1].oprclass = 0;
+					y->operand[0].oprclass = y->operand[1].oprclass = NO_REF;
 				} else
 				{
 					oct &= OCT_VALUE | OCT_MVADDR;
@@ -186,7 +170,7 @@ void alloc_reg(void)
 					for (c = 0; tempcont[r][c] && (MAX_TEMP_COUNT > c); c++)
 						;
 					if (MAX_TEMP_COUNT <= c)
-						rts_error(VARLSTCNT(1) ERR_TMPSTOREMAX);
+						rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) ERR_TMPSTOREMAX);
 					tempcont[r][c] = 1;
 					x->destination.oprclass = r;
 					x->destination.oprval.temp = c;
@@ -201,6 +185,27 @@ void alloc_reg(void)
 			assert(x->destination.oprval.tref->destination.oprclass);
 			x->destination = x->destination.oprval.tref->destination;
 		}
+		for (j = x->operand, y = x; j < ARRAYTOP(y->operand); )
+		{	/* Loop through all the parameters of the current opcode. For each parameter that requires an intermediate
+			 * temporary, decrement (this is what remove_backptr does) the "reference count" -- opcodes yet to be
+			 * processed that still need the intermediate result -- and if that number is zero, mark the temporary
+			 * available. We can then reuse the temp to hold the results of subsequent opcodes. Note that remove_backptr
+			 * is essentially the resolve_tref() in resolve_ref.c. resolve_tref increments the "reference count",
+			 * while remove_backptr decrements it.
+			 */
+			if (TRIP_REF == j->oprclass)
+			{
+				ref = j->oprval.tref;
+				if (OC_PARAMETER == ref->opcode)
+				{
+					y = ref;
+					j = y->operand;
+					continue;
+				}
+				remove_backptr(y, j, tempcont);
+			}
+			j++;
+		}
 	}
 	for (r = 0; VALUED_REF_TYPES > r; r++)
 		sa_temps[r] = temphigh[r] + 1;
@@ -208,10 +213,40 @@ void alloc_reg(void)
 	size = sa_temps[TVAL_REF] * sa_class_sizes[TVAL_REF];
 	sa_temps_offset[TVAL_REF] = size;
 	/* Since we need to align the temp region to the largest types, align even int temps to SIZEOF(char*) */
-	size += ROUND_UP2(sa_temps[TINT_REF] * sa_class_sizes[TINT_REF], SIZEOF(char *));
+	size += ROUND_UP2(sa_temps[TINT_REF] *sa_class_sizes[TINT_REF], SIZEOF(char *));
 	sa_temps_offset[TINT_REF] = size;
 	size += sa_temps[TVAD_REF] * sa_class_sizes[TVAD_REF];
 	sa_temps_offset[TVAD_REF] = size;
 	size += sa_temps[TCAD_REF] * sa_class_sizes[TCAD_REF];
 	sa_temps_offset[TCAD_REF] = size;
 }
+
+void remove_backptr(triple *curtrip, oprtype *opnd, char (*tempcont)[MAX_TEMP_COUNT])
+{
+	triple		*ref;
+	tbp		*b;
+	int		r;
+
+	assert(TRIP_REF == opnd->oprclass);
+	ref = opnd->oprval.tref;
+	while (OC_PASSTHRU == opnd->oprval.tref->opcode)
+	{
+		ref = ref->operand[0].oprval.tref;
+		opnd = &ref->operand[0];
+		assert(TRIP_REF == opnd->oprclass);
+	}
+	r = ref->destination.oprclass;
+	if (NO_REF != r)
+	{
+		dqloop(&ref->backptr, que, b)
+		{
+			if (b->bpt == curtrip)
+			{
+				dqdel(b, que);
+				break;
+			}
+		}
+		if ((ref->backptr.que.fl == &ref->backptr) && (TVAR_REF != r))
+			tempcont[r][ref->destination.oprval.temp] = 0;
+	}
+}

sr_port/anticipatory_freeze.h

@@ -0,0 +1,344 @@
+/****************************************************************
+ *								*
+ *	Copyright 2012, 2013 Fidelity Information Services, Inc	*
+ *								*
+ *	This source code contains the intellectual property	*
+ *	of its copyright holder(s), and is made available	*
+ *	under a license.  If you do not know the terms of	*
+ *	the license, please stop and do not read further.	*
+ *								*
+ ****************************************************************/
+#ifndef _ANTICIPATORY_FREEZE_H
+#define _ANTICIPATORY_FREEZE_H
+
+#ifdef UNIX
+
+#include "gtm_time.h"			/* needed for GET_CUR_TIME */
+#include "gdsroot.h"
+#include "gdsbt.h"
+#include "gdsblk.h"
+#include "gdsfhead.h"
+#include "repl_msg.h"			/* needed for gtmsource.h */
+#include "gtmsource.h"			/* needed for jnlpool_addrs typedef */
+#include "sleep_cnt.h"			/* needed for SLEEP_INSTFREEZEWAIT macro */
+#include "wait_for_disk_space.h"	/* needed by DB_LSEEKWRITE macro for prototype */
+#include "gtmimagename.h"		/* needed for IS_GTM_IMAGE */
+
+boolean_t		is_anticipatory_freeze_needed(sgmnt_addrs *csa, int msg_id);
+void			set_anticipatory_freeze(sgmnt_addrs *csa, int msg_id);
+boolean_t		init_anticipatory_freeze_errors(void);
+
+/* Define function pointers to certain functions to avoid executables like gtmsecshr from unnecessarily
+ * linking with these functions (which causes the database/replication stuff to be pulled in).
+ */
+typedef boolean_t	(*is_anticipatory_freeze_needed_t)(sgmnt_addrs *csa, int msgid);
+typedef void		(*set_anticipatory_freeze_t)(sgmnt_addrs *csa, int msg_id);
+
+GBLREF	is_anticipatory_freeze_needed_t		is_anticipatory_freeze_needed_fnptr;
+GBLREF	set_anticipatory_freeze_t		set_anticipatory_freeze_fnptr;
+GBLREF	boolean_t				pool_init;
+GBLREF	boolean_t				mupip_jnl_recover;
+#ifdef DEBUG
+GBLREF	uint4	  				lseekwrite_target;
+#endif
+
+error_def(ERR_MUINSTFROZEN);
+error_def(ERR_MUINSTUNFROZEN);
+
+error_def(ERR_MUNOACTION);
+error_def(ERR_REPLINSTFREEZECOMMENT);
+error_def(ERR_REPLINSTFROZEN);
+error_def(ERR_REPLINSTUNFROZEN);
+error_def(ERR_TEXT);
+
+
+#define ENABLE_FREEZE_ON_ERROR											\
+{														\
+	if (ANTICIPATORY_FREEZE_AVAILABLE)									\
+	{	/* Set anticipatory freeze function pointers to be used later (in send_msg and rts_error) */	\
+		is_anticipatory_freeze_needed_fnptr = &is_anticipatory_freeze_needed;				\
+		set_anticipatory_freeze_fnptr = &set_anticipatory_freeze;					\
+	}													\
+}
+
+#define CHECK_IF_FREEZE_ON_ERROR_NEEDED(CSA, MSG_ID, FREEZE_NEEDED, FREEZE_MSG_ID)					\
+{															\
+	GBLREF	jnlpool_addrs		jnlpool;									\
+	DCL_THREADGBL_ACCESS;												\
+															\
+	SETUP_THREADGBL_ACCESS;												\
+	if (!FREEZE_NEEDED && ANTICIPATORY_FREEZE_AVAILABLE && (NULL != is_anticipatory_freeze_needed_fnptr))		\
+	{	/* NOT gtmsecshr */											\
+		if (IS_REPL_INST_UNFROZEN && (*is_anticipatory_freeze_needed_fnptr)((sgmnt_addrs *)CSA, MSG_ID))	\
+		{													\
+			FREEZE_NEEDED = TRUE;										\
+			FREEZE_MSG_ID = MSG_ID;										\
+		}													\
+	}														\
+}
+
+#define FREEZE_INSTANCE_IF_NEEDED(CSA, FREEZE_NEEDED, FREEZE_MSG_ID)								\
+{																\
+	GBLREF	jnlpool_addrs		jnlpool;										\
+																\
+	if (FREEZE_NEEDED)													\
+	{															\
+		assert(NULL != set_anticipatory_freeze_fnptr);									\
+		(*set_anticipatory_freeze_fnptr)((sgmnt_addrs *)CSA, FREEZE_MSG_ID);						\
+		send_msg_csa(CSA_ARG(NULL) VARLSTCNT(3) ERR_REPLINSTFROZEN, 1,							\
+				jnlpool.repl_inst_filehdr->inst_info.this_instname);						\
+		send_msg_csa(CSA_ARG(NULL) VARLSTCNT(3) ERR_REPLINSTFREEZECOMMENT, 1, jnlpool.jnlpool_ctl->freeze_comment);	\
+	}															\
+}
+
+#define CLEAR_ANTICIPATORY_FREEZE(FREEZE_CLEARED)									\
+{															\
+	GBLREF	jnlpool_addrs		jnlpool;									\
+															\
+	if (IS_REPL_INST_FROZEN)											\
+	{														\
+		jnlpool.jnlpool_ctl->freeze = 0;									\
+		FREEZE_CLEARED = TRUE;											\
+	}														\
+}
+
+#define REPORT_INSTANCE_UNFROZEN(FREEZE_CLEARED)										\
+{																\
+	GBLREF	jnlpool_addrs		jnlpool;										\
+																\
+	if (FREEZE_CLEARED)													\
+		send_msg_csa(CSA_ARG(NULL) VARLSTCNT(3) ERR_REPLINSTUNFROZEN, 1,						\
+				jnlpool.repl_inst_filehdr->inst_info.this_instname);						\
+}
+
+#define AFREEZE_MASK				0x01
+#define ANTICIPATORY_FREEZE_AVAILABLE		(0 != (TREF(gtm_custom_errors)).len)
+#define INSTANCE_FREEZE_HONORED(CSA)		(DBG_ASSERT(NULL != CSA)							\
+							((NULL != jnlpool.jnlpool_ctl)						\
+								&& ((REPL_ALLOWED(((sgmnt_addrs *)CSA)->hdr))			\
+							    		|| mupip_jnl_recover	/* recover or rollback */	\
+									|| ((sgmnt_addrs *)CSA)->nl->onln_rlbk_pid )))
+#define ANTICIPATORY_FREEZE_ENABLED(CSA)	(INSTANCE_FREEZE_HONORED(CSA)				\
+							&& ANTICIPATORY_FREEZE_AVAILABLE		\
+							&& (((sgmnt_addrs *)CSA)->hdr->freeze_on_fail))
+#define IS_REPL_INST_FROZEN			((NULL != jnlpool.jnlpool_ctl) && jnlpool.jnlpool_ctl->freeze)
+#define IS_REPL_INST_UNFROZEN			((NULL != jnlpool.jnlpool_ctl) && !jnlpool.jnlpool_ctl->freeze)
+
+#define INST_FROZEN_COMMENT			"PID %d encountered %s; Instance frozen"
+
+#define MSGID_TO_ERRMSG(MSG_ID, ERRMSG)				\
+{								\
+	const err_ctl		*ctl;				\
+								\
+	ctl = err_check(MSG_ID);				\
+	assert(NULL != ctl);					\
+	GET_MSG_INFO(MSG_ID, ctl, ERRMSG);			\
+}
+
+#define GENERATE_INST_FROZEN_COMMENT(BUF, BUF_LEN, MSG_ID)			\
+{										\
+	GBLREF uint4		process_id;					\
+	const err_msg		*msginfo;					\
+										\
+	MSGID_TO_ERRMSG(MSG_ID, msginfo);					\
+	SNPRINTF(BUF, BUF_LEN, INST_FROZEN_COMMENT, process_id, msginfo->tag);	\
+}
+
+/* This is a version of the macro which waits for the instance freeze to be lifted off assuming the process has
+ * already attached to the journal pool. We need to wait for the freeze only if the input database cares about
+ * anticipatory freeze. Examples of those databases that dont care are non-replicated databases, databases with
+ * "freeze_on_fail" field set to FALSE in the file header etc. Hence the use of ANTICIPATORY_FREEZE_ENABLED below.
+ * Note: Do not use "hiber_start" as that uses timers and if we are already in a timer handler now, nested timers
+ * wont work. Since SHORT_SLEEP allows a max of 1000, we use 500 (half a second) for now.
+ */
+#define WAIT_FOR_REPL_INST_UNFREEZE(CSA)											\
+{																\
+	gd_region	*reg;													\
+	char		*time_ptr, time_str[CTIME_BEFORE_NL + 2]; /* for GET_CUR_TIME macro */					\
+	now_t		now;													\
+	DCL_THREADGBL_ACCESS;													\
+																\
+	SETUP_THREADGBL_ACCESS;													\
+	assert(NULL != CSA);													\
+	if (INSTANCE_FREEZE_HONORED(CSA))											\
+	{															\
+		reg = ((sgmnt_addrs *)CSA)->region;										\
+		if (!IS_GTM_IMAGE)												\
+		{														\
+			GET_CUR_TIME;												\
+			gtm_putmsg_csa(CSA_ARG(NULL) VARLSTCNT(7) ERR_MUINSTFROZEN, 5, CTIME_BEFORE_NL, time_ptr,		\
+					jnlpool.repl_inst_filehdr->inst_info.this_instname, DB_LEN_STR(reg));			\
+		}														\
+		WAIT_FOR_REPL_INST_UNFREEZE_NOCSA;										\
+		if (!IS_GTM_IMAGE)												\
+		{														\
+			GET_CUR_TIME;												\
+			gtm_putmsg_csa(CSA_ARG(NULL) VARLSTCNT(7) ERR_MUINSTUNFROZEN, 5, CTIME_BEFORE_NL, time_ptr,		\
+					jnlpool.repl_inst_filehdr->inst_info.this_instname, DB_LEN_STR(reg));			\
+		}														\
+	}															\
+}
+/* This is a safer version of the WAIT_FOR_REPL_INST_UNFREEZE macro, which waits for the instance freeze
+ * to be lifted off but is not sure if the process has access to the journal pool yet.
+ * If it does not, then it assumes the instance is not frozen.
+ */
+#define WAIT_FOR_REPL_INST_UNFREEZE_SAFE(CSA)		\
+{							\
+	GBLREF	jnlpool_addrs	jnlpool;		\
+							\
+	assert(NULL != CSA);				\
+	if (IS_REPL_INST_FROZEN)			\
+		WAIT_FOR_REPL_INST_UNFREEZE(CSA);	\
+}
+
+/* Below are similar macros like the above but with no CSA to specifically check for */
+#define	WAIT_FOR_REPL_INST_UNFREEZE_NOCSA						\
+{											\
+	GBLREF	jnlpool_addrs	jnlpool;						\
+	GBLREF	volatile int4	exit_state;						\
+	GBLREF	int4		exi_condition;						\
+	GBLREF	int4		forced_exit_err;					\
+											\
+	assert(NULL != jnlpool.jnlpool_ctl);						\
+	/* If this region is not replicated, do not care for instance freezes */	\
+	while (jnlpool.jnlpool_ctl->freeze)						\
+	{										\
+		if (exit_state != 0)							\
+		{									\
+			send_msg_csa(CSA_ARG(NULL) VARLSTCNT(1) forced_exit_err);	\
+			gtm_putmsg_csa(CSA_ARG(NULL) VARLSTCNT(1) forced_exit_err);	\
+			exit(-exi_condition);						\
+		}									\
+		SHORT_SLEEP(SLEEP_INSTFREEZEWAIT);					\
+		DEBUG_ONLY(CLEAR_FAKE_ENOSPC_IF_MASTER_DEAD);				\
+	}										\
+}
+#define WAIT_FOR_REPL_INST_UNFREEZE_NOCSA_SAFE		\
+{							\
+	GBLREF	jnlpool_addrs	jnlpool;		\
+							\
+	if (IS_REPL_INST_FROZEN)			\
+		WAIT_FOR_REPL_INST_UNFREEZE_NOCSA;	\
+}
+
+/* GTM_DB_FSYNC/GTM_JNL_FSYNC are similar to GTM_FSYNC except that we dont do the fsync
+ * (but instead hang) if we detect the instance is frozen. We proceed with the fsync once the freeze clears.
+ * CSA is a parameter indicating which database it is that we want to fsync.
+ * GTM_REPL_INST_FSYNC is different in that we currently dont care about instance freeze for replication
+ * instance file writes.
+ */
+#define GTM_DB_FSYNC(CSA, FD, RC)						\
+{										\
+	GBLREF	jnlpool_addrs		jnlpool;				\
+	node_local_ptr_t		cnl;					\
+										\
+	assert((NULL != CSA) || (NULL == jnlpool.jnlpool_ctl));			\
+	if (NULL != CSA)							\
+	{									\
+		WAIT_FOR_REPL_INST_UNFREEZE_SAFE(CSA);				\
+		cnl = (CSA)->nl;						\
+		if (NULL != cnl)						\
+			INCR_GVSTATS_COUNTER((CSA), cnl, n_db_fsync, 1);	\
+	}									\
+	GTM_FSYNC(FD, RC);							\
+}
+
+#define GTM_JNL_FSYNC(CSA, FD, RC)						\
+{										\
+	GBLREF	jnlpool_addrs		jnlpool;				\
+	node_local_ptr_t		cnl;					\
+										\
+	assert((NULL != CSA) || (NULL == jnlpool.jnlpool_ctl));			\
+	if (NULL != CSA)							\
+	{									\
+		WAIT_FOR_REPL_INST_UNFREEZE_SAFE(CSA);				\
+		cnl = (CSA)->nl;						\
+		if (NULL != cnl)						\
+			INCR_GVSTATS_COUNTER((CSA), cnl, n_jnl_fsync, 1);	\
+	}									\
+	GTM_FSYNC(FD, RC);							\
+}
+
+#define GTM_REPL_INST_FSYNC(FD, RC)	GTM_FSYNC(FD, RC)
+
+#define	LSEEKWRITE_IS_TO_NONE		0
+#define	LSEEKWRITE_IS_TO_DB		1
+#define	LSEEKWRITE_IS_TO_JNL		2
+
+#ifdef DEBUG
+#define	FAKE_ENOSPC(CSA, FAKE_WHICH_ENOSPC, LSEEKWRITE_TARGET, LCL_STATUS)						\
+{															\
+	GBLREF	jnlpool_addrs		jnlpool;									\
+	if (NULL != CSA)												\
+	{														\
+		if (WBTEST_ENABLED(WBTEST_RECOVER_ENOSPC))								\
+		{	/* This test case is only used by mupip */							\
+			gtm_wbox_input_test_case_count++;								\
+			if ((0 != gtm_white_box_test_case_count)							\
+			    && (gtm_white_box_test_case_count <= gtm_wbox_input_test_case_count))			\
+			{												\
+				LCL_STATUS = ENOSPC;									\
+				if (gtm_white_box_test_case_count == gtm_wbox_input_test_case_count)			\
+					send_msg_csa(CSA_ARG(NULL) VARLSTCNT(4) ERR_TEXT, 2,				\
+					     LEN_AND_LIT("Turning on fake ENOSPC for exit status test"));		\
+			}												\
+		} else if (!IS_DSE_IMAGE /*DSE does not freeze so let it work as normal */				\
+			   && ((NULL != jnlpool.jnlpool_ctl) && (NULL != ((sgmnt_addrs *)CSA)->nl))			\
+			   && ((sgmnt_addrs *)CSA)->nl->FAKE_WHICH_ENOSPC)						\
+		{													\
+			LCL_STATUS = ENOSPC;										\
+			lseekwrite_target = LSEEKWRITE_TARGET;								\
+		}													\
+	}														\
+}
+
+void clear_fake_enospc_if_master_dead(void);
+
+#define CLEAR_FAKE_ENOSPC_IF_MASTER_DEAD	clear_fake_enospc_if_master_dead()
+
+#else
+#define	FAKE_ENOSPC(CSA, FAKE_ENOSPC, LSEEKWRITE_TARGET, LCL_STATUS) {}
+#endif
+
+
+#define	DB_LSEEKWRITE(csa, db_fn, fd, new_eof, buff, size, status)							\
+	DO_LSEEKWRITE(csa, db_fn, fd, new_eof, buff, size, status, fake_db_enospc, LSEEKWRITE_IS_TO_DB)
+
+#define	JNL_LSEEKWRITE(csa, jnl_fn, fd, new_eof, buff, size, status)							\
+	DO_LSEEKWRITE(csa, jnl_fn, fd, new_eof, buff, size, status, fake_jnl_enospc, LSEEKWRITE_IS_TO_JNL)
+
+#define DO_LSEEKWRITE(csa, fnptr, fd, new_eof, buff, size, status, FAKE_WHICH_ENOSPC, LSEEKWRITE_TARGET)			\
+{																\
+	int	lcl_status;													\
+																\
+	if (NULL != csa)													\
+		WAIT_FOR_REPL_INST_UNFREEZE_SAFE(csa);										\
+	LSEEKWRITE(fd, new_eof, buff, size, lcl_status);									\
+	FAKE_ENOSPC(csa, FAKE_WHICH_ENOSPC, LSEEKWRITE_TARGET, lcl_status);							\
+	if (ENOSPC == lcl_status)												\
+	{															\
+		wait_for_disk_space(csa, (char *)fnptr, fd, (off_t)new_eof, (char *)buff, (size_t)size, &lcl_status);		\
+		assert((NULL == csa) || (NULL == ((sgmnt_addrs *)csa)->nl) || !((sgmnt_addrs *)csa)->nl->FAKE_WHICH_ENOSPC	\
+		       || (ENOSPC != lcl_status));										\
+	}															\
+	status = lcl_status;													\
+}
+
+/* Currently, writes to replication instance files do NOT trigger instance freeze behavior.
+ * Neither does a pre-existing instance freeze affect replication instance file writes.
+ * Hence this is defined as simple LSEEKWRITE.
+ */
+#define	REPL_INST_LSEEKWRITE	LSEEKWRITE
+
+#define REPL_INST_AVAILABLE	(repl_inst_get_name((char *)replpool_id.instfilename, &full_len, SIZEOF(replpool_id.instfilename), \
+							return_on_error))
+
+#else	/* #ifdef UNIX */
+#	define ANTICIPATORY_FREEZE_AVAILABLE			FALSE
+#	define ANTICIPATORY_FREEZE_ENABLED(CSA)			FALSE
+#	define REPL_INST_AVAILABLE				FALSE
+#	define WAIT_FOR_REPL_INST_UNFREEZE
+#	define WAIT_FOR_REPL_INST_UNFREEZE_SAFE
+#endif	/* #ifdef UNIX */
+
+#endif	/* #ifndef _ANTICIPATORY_FREEZE_H */

sr_port/asc_hex2i.c

@@ -1,6 +1,6 @@
 /****************************************************************
  *								*
- *	Copyright 2001 Sanchez Computer Associates, Inc.	*
+ *	Copyright 2001, 2013 Fidelity Information Services, Inc	*
  *								*
  *	This source code contains the intellectual property	*
  *	of its copyright holder(s), and is made available	*
@@ -11,24 +11,53 @@
 
 #include "mdef.h"
 
-unsigned int asc_hex2i(p,len)
+LITREF unsigned char lower_to_upper_table[];
-char *p;
+
-int  len;
+unsigned int asc_hex2i(uchar_ptr_t p, int len)
 {
-	char	*c;
+	uchar_ptr_t	c;
-	int	ret;
+	unsigned char	ch;
+	int		ret;
 
 	ret = 0;
 	for (c = p + len; c > p; p++)
 	{
-		if (*p >= '0' && *p <= '9')
+		if (('0' <= *p) && ('9' >= *p))
-			ret = ret * 16 + *p - '0';
+			ret = (ret << 4) + (*p - '0');
-		else if (*p >= 'a' && *p <= 'f')
-			ret = ret * 16 + *p - 'a' + 10;
-		else if (*p >= 'A' && *p <= 'F')
-			ret = ret * 16 + *p - 'A' + 10;
 		else
-			return (uint4)-1;
+		{
+			ch = lower_to_upper_table[*p];
+			if (('A' <= ch) && ('F' >= ch))
+				ret = (ret << 4) + ch - 'A' + 10;
+			else
+				return (unsigned int)-1;
+		}
 	}
 	return ret;
 }
+
+#ifndef VMS
+/* Routine identical to asc_hex2i() but with 8 byte accumulator and return type */
+gtm_uint64_t  asc_hex2l(uchar_ptr_t p, int len)
+{
+	uchar_ptr_t	c;
+	unsigned char	ch;
+	gtm_uint64_t	ret;
+
+	ret = 0;
+	for (c = p + len; c > p; p++)
+	{
+		if (('0' <= *p) && ('9' >= *p))
+			ret = (ret << 4) + (*p - '0');
+		else
+		{
+			ch = lower_to_upper_table[*p];
+			if (('A' <= ch) && ('F' >= ch))
+				ret = (ret << 4) + ch - 'A' + 10;
+			else
+				return (gtm_uint64_t)-1;
+		}
+	}
+	return ret;
+}
+#endif

sr_port/base_frame.c

@@ -13,7 +13,8 @@
 
 #include "gtm_string.h"
 
-#include "rtnhdr.h"
+#include "error.h"	/* For DBGEHND() */
+#include <rtnhdr.h>
 #include "stack_frame.h"
 
 GBLREF unsigned char 	*stacktop, *stackwarn, *msp;
@@ -61,4 +62,5 @@ void base_frame(rhdtyp *base_address)
 	fp->type = SFT_COUNT;
 	fp->ret_value = NULL;
 	fp->dollar_test = -1;
+	DBGEHND((stderr, "base_frame: New base frame allocated at 0x"lvaddr"\n", fp));
 }

sr_port/bm_getfree.c

@@ -1,6 +1,6 @@
 /****************************************************************
  *								*
- *	Copyright 2001, 2012 Fidelity Information Services, Inc	*
+ *	Copyright 2001, 2013 Fidelity Information Services, Inc	*
  *								*
  *	This source code contains the intellectual property	*
  *	of its copyright holder(s), and is made available	*
@@ -67,6 +67,9 @@ GBLREF uint4		dollar_tlevel;
 GBLREF uint4		update_array_size, cumul_update_array_size;
 GBLREF unsigned int	t_tries;
 
+error_def(ERR_DBBADFREEBLKCTR);
+error_def(ERR_DBMBMINCFREFIXED);
+
 block_id bm_getfree(block_id orig_hint, boolean_t *blk_used, unsigned int cw_work, cw_set_element *cs, int *cw_depth_ptr)
 {
 	cw_set_element	*cs1;
@@ -81,18 +84,7 @@ block_id bm_getfree(block_id orig_hint, boolean_t *blk_used, unsigned int cw_wor
 	uint4		status;
 	srch_blk_status	blkhist;
 
-#	ifdef GTM_TRUNCATE
-	if (dba_mm == cs_data->acc_meth)
-	{
-		total_blks = cs_addrs->total_blks;
-	} else
-	{
-		total_blks = cs_addrs->ti->total_blks;
-		cs_addrs->total_blks = MAX(cs_addrs->total_blks, total_blks);
-	}
-#	else
 	total_blks = (dba_mm == cs_data->acc_meth) ? cs_addrs->total_blks : cs_addrs->ti->total_blks;
-#	endif
 	if (orig_hint >= total_blks)		/* for TP, hint can be > total_blks */
 		orig_hint = 1;
 	hint = orig_hint;
@@ -110,16 +102,12 @@ block_id bm_getfree(block_id orig_hint, boolean_t *blk_used, unsigned int cw_wor
 				hint = 1;
 				continue;
 			}
-			if (SS_NORMAL != (status = gdsfilext(cs_data->extension_size, total_blks)))
+			if (SS_NORMAL != (status = GDSFILEXT(cs_data->extension_size, total_blks, TRANS_IN_PROG_TRUE)))
 				return (status);
 			if (dba_mm == cs_data->acc_meth)
 				return (FILE_EXTENDED);
 			hint = total_blks;
 			total_blks = cs_addrs->ti->total_blks;
-#			ifdef GTM_TRUNCATE
-			assert(dba_mm != cs_data->acc_meth);
- 			cs_addrs->total_blks = MAX(cs_addrs->total_blks, total_blks);
-#			endif
 			hint_cycled = DIVIDE_ROUND_UP(total_blks, BLKS_PER_LMAP);
 			local_maps = hint_cycled + 2;	/* for (up to) 2 wraps */
 			/*
@@ -214,14 +202,21 @@ block_id bm_getfree(block_id orig_hint, boolean_t *blk_used, unsigned int cw_wor
 			if (hint_cycled)
 				hint_cycled = (hint_limit < hint_cycled) ? hint_limit: 0;
 		}
-		if ((0 == depth) && (FALSE != cs_addrs->now_crit))	/* if it's from the cw_set, its state is murky */
+		if ((0 == depth) && cs_addrs->now_crit)	/* if it's from the cw_set, its state is murky */
-			bit_clear(bml / BLKS_PER_LMAP, MM_ADDR(cs_data));	/* if crit, repair master map error */
+		{
+			assert(FALSE);
+			send_msg_csa(CSA_ARG(cs_addrs) VARLSTCNT(3) ERR_DBMBMINCFREFIXED, 1, bml);
+			bit_clear(bml / BLKS_PER_LMAP, MM_ADDR(cs_data)); /* repair master map error */
+		}
 	}
-	/* If not in the final retry, it is possible that free_bit is >= map_size (e.g. if bitmap block gets recycled). */
+	/* If not in the final retry, it is possible that free_bit is >= map_size, e.g., if the buffer holding the bitmap block
-	if (map_size <= (uint4)free_bit && CDB_STAGNATE <= t_tries)
+	 * gets recycled with a non-bitmap block in which case the bit that bm_find_blk returns could be greater than map_size.
-	{	/* bad free bit */
+	 * But, this should never happen in final retry.
+	 */
+	if ((map_size <= (uint4)free_bit) && (CDB_STAGNATE <= t_tries))
+	{	/* Bad free bit. */
 		assert((NO_FREE_SPACE == free_bit) && (lcnt > local_maps));	/* All maps full, should have extended */
-		GTMASSERT;
+		assertpro(FALSE);
 	}
 	if (0 != depth)
 	{
@@ -263,8 +258,6 @@ boolean_t	is_free_blks_ctr_ok(void)
 	sm_uc_ptr_t	bmp;
 	unsigned int	local_maps, total_blks, free_blocks;
 
-	error_def(ERR_DBBADFREEBLKCTR);
-
 	assert(&FILE_INFO(gv_cur_region)->s_addrs == cs_addrs && cs_addrs->hdr == cs_data && cs_addrs->now_crit);
 	total_blks = (dba_mm == cs_data->acc_meth) ? cs_addrs->total_blks : cs_addrs->ti->total_blks;
 	local_maps = DIVIDE_ROUND_UP(total_blks, BLKS_PER_LMAP);
@@ -296,7 +289,8 @@ boolean_t	is_free_blks_ctr_ok(void)
 	assert(cs_addrs->ti->free_blocks == free_blocks);
 	if (cs_addrs->ti->free_blocks != free_blocks)
 	{
-		send_msg(VARLSTCNT(6) ERR_DBBADFREEBLKCTR, 4, DB_LEN_STR(gv_cur_region), cs_addrs->ti->free_blocks, free_blocks);
+		send_msg_csa(CSA_ARG(cs_addrs) VARLSTCNT(6) ERR_DBBADFREEBLKCTR, 4, DB_LEN_STR(gv_cur_region),
+				cs_addrs->ti->free_blocks, free_blocks);
 		cs_addrs->ti->free_blocks = free_blocks;
 		return FALSE;
 	}

sr_port/bm_setmap.c

@@ -1,6 +1,6 @@
 /****************************************************************
  *								*
- *	Copyright 2001, 2011 Fidelity Information Services, Inc	*
+ *	Copyright 2001, 2013 Fidelity Information Services, Inc	*
  *								*
  *	This source code contains the intellectual property	*
  *	of its copyright holder(s), and is made available	*
@@ -35,13 +35,13 @@
 #include "gvcst_map_build.h"
 #include "mm_read.h"
 
-GBLREF gd_region	*gv_cur_region;
+GBLREF	gd_region		*gv_cur_region;
-GBLREF sgmnt_addrs	*cs_addrs;
+GBLREF	sgmnt_addrs		*cs_addrs;
-GBLREF sgmnt_data_ptr_t cs_data;
+GBLREF	sgmnt_data_ptr_t	cs_data;
-GBLREF char		*update_array, *update_array_ptr;
+GBLREF	char			*update_array, *update_array_ptr;
-GBLREF cw_set_element	cw_set[];
+GBLREF	cw_set_element		cw_set[];
-GBLREF unsigned char	rdfail_detail;
+GBLREF	unsigned char		rdfail_detail;
-GBLREF unsigned char    *non_tp_jfb_buff_ptr;
+GBLREF	jnl_format_buffer	*non_tp_jfb_ptr;
 
 void bm_setmap(block_id bml, block_id blk, int4 busy)
 {
@@ -96,8 +96,8 @@ void bm_setmap(block_id bml, block_id blk, int4 busy)
 	if (JNL_ENABLED(cs_data))
         {
                 cse = (cw_set_element *)(&cw_set[0]);
-                cse->new_buff = non_tp_jfb_buff_ptr;
+                cse->new_buff = (unsigned char *)non_tp_jfb_ptr->buff;
-                memcpy(non_tp_jfb_buff_ptr, bmp, ((blk_hdr_ptr_t)bmp)->bsiz);
+                memcpy(cse->new_buff, bmp, ((blk_hdr_ptr_t)bmp)->bsiz);
                 gvcst_map_build((uint4 *)cse->upd_addr, (uchar_ptr_t)cse->new_buff, cse, cs_addrs->ti->curr_tn);
                 cse->done = TRUE;
         }

sr_port/bool_expr.c

@@ -1,6 +1,6 @@
 /****************************************************************
  *								*
- *	Copyright 2001, 2011 Fidelity Information Services, Inc	*
+ *	Copyright 2001, 2012 Fidelity Information Services, Inc	*
  *								*
  *	This source code contains the intellectual property	*
  *	of its copyright holder(s), and is made available	*
@@ -10,6 +10,7 @@
  ****************************************************************/
 
 #include "mdef.h"
+#include "gtm_string.h"		/* needed by INCREMENT_EXPR_DEPTH */
 #include "compiler.h"
 #include "opcode.h"
 
@@ -19,17 +20,15 @@ int bool_expr(boolean_t op, oprtype *addr)
 	DCL_THREADGBL_ACCESS;
 
 	SETUP_THREADGBL_ACCESS;
-	if (!(TREF(expr_depth))++)
+	INCREMENT_EXPR_DEPTH;
-		TREF(expr_start) = TREF(expr_start_orig) = NULL;
 	if (!eval_expr(&x))
 	{
-		TREF(expr_depth) = 0;
+		DECREMENT_EXPR_DEPTH;
 		return FALSE;
 	}
 	assert(TRIP_REF == x.oprclass);
 	coerce(&x, OCT_BOOL);
 	bx_tail(x.oprval.tref, op, addr);
-	if (!(--(TREF(expr_depth))))
+	DECREMENT_EXPR_DEPTH;
-		TREF(saw_side_effect) = TREF(shift_side_effects) = FALSE;
 	return TRUE;
 }

sr_port/bt_get.c

@@ -1,6 +1,6 @@
 /****************************************************************
  *								*
- *	Copyright 2001, 2010 Fidelity Information Services, Inc	*
+ *	Copyright 2001, 2012 Fidelity Information Services, Inc	*
  *								*
  *	This source code contains the intellectual property	*
  *	of its copyright holder(s), and is made available	*
@@ -40,7 +40,7 @@ bt_rec_ptr_t bt_get(int4 block)		/* block = block # to get */
 		if (bt->blk == BT_QUEHEAD)
 			return NULL;
 	}
-	SET_TRACEABLE_VAR(csa->hdr->wc_blocked, TRUE);
+	SET_TRACEABLE_VAR(csa->nl->wc_blocked, TRUE);
 	BG_TRACE_PRO_ANY(csa, wc_blocked_bt_get);
 	return NULL;	/* actually should return BT_INVALID or some such value but callers check only for NULL */
 }

sr_port/bt_init.c

@@ -1,6 +1,6 @@
 /****************************************************************
  *								*
- *	Copyright 2001 Sanchez Computer Associates, Inc.	*
+ *	Copyright 2001, 2013 Fidelity Information Services, Inc	*
  *								*
  *	This source code contains the intellectual property	*
  *	of its copyright holder(s), and is made available	*
@@ -16,14 +16,17 @@
 #include "gdsbt.h"
 #include "gdsfhead.h"
 
-void bt_init(sgmnt_addrs *cs)
+void bt_init(sgmnt_addrs *csa)
 {
-	sgmnt_data_ptr_t base;
+	sgmnt_data_ptr_t csd;
 
-	base = cs->hdr;
+	csd = csa->hdr;
-	cs->ti = &base->trans_hist;
+	csa->ti = &csd->trans_hist;
-	cs->bt_header = (bt_rec_ptr_t)((sm_uc_ptr_t) base + cs->nl->bt_header_off);
+	if (dba_mm != csd->acc_meth)
-	cs->bt_base = (bt_rec_ptr_t)((sm_uc_ptr_t) base + cs->nl->bt_base_off);
+	{	/* BT structures are NOT maintained for MM */
-	cs->th_base = (th_rec_ptr_t)((sm_uc_ptr_t) base + cs->nl->th_base_off);
+		csa->bt_header = (bt_rec_ptr_t)((sm_uc_ptr_t) csd + csa->nl->bt_header_off);
+		csa->bt_base = (bt_rec_ptr_t)((sm_uc_ptr_t) csd + csa->nl->bt_base_off);
+		csa->th_base = (th_rec_ptr_t)((sm_uc_ptr_t) csd + csa->nl->th_base_off);
+	}
 	return;
 }

sr_port/bt_put.c

@@ -1,6 +1,6 @@
 /****************************************************************
  *								*
- *	Copyright 2001, 2009 Fidelity Information Services, Inc	*
+ *	Copyright 2001, 2013 Fidelity Information Services, Inc	*
  *								*
  *	This source code contains the intellectual property	*
  *	of its copyright holder(s), and is made available	*
@@ -35,6 +35,9 @@ GBLREF	volatile boolean_t	in_wcs_recover;	/* TRUE if in "wcs_recover" */
 GBLREF	uint4			process_id;
 GBLREF 	jnl_gbls_t		jgbl;
 
+error_def(ERR_BTFAIL);
+error_def(ERR_WCBLOCKED);
+
 bt_rec_ptr_t bt_put(gd_region *reg, int4 block)
 {
 	bt_rec_ptr_t		bt, q0, q1, hdr;
@@ -45,10 +48,6 @@ bt_rec_ptr_t bt_put(gd_region *reg, int4 block)
 	trans_num		lcl_tn;
 	uint4			lcnt;
 
-	error_def(ERR_BTFAIL);
-	error_def(ERR_WCFAIL);
-	error_def(ERR_WCBLOCKED);
-
 	csa = (sgmnt_addrs *)&FILE_INFO(reg)->s_addrs;
 	csd = csa->hdr;
 	assert(csa->now_crit || csd->clustered);
@@ -72,7 +71,7 @@ bt_rec_ptr_t bt_put(gd_region *reg, int4 block)
 					BG_TRACE_PRO_ANY(csa, bt_put_flush_dirty);
 					if (FALSE == wcs_get_space(reg, 0, cr))
 					{
-						assert(csd->wc_blocked);	/* only reason we currently know
+						assert(csa->nl->wc_blocked);	/* only reason we currently know
 										 * why wcs_get_space could fail */
 						assert(gtm_white_box_test_case_enabled);
 						BG_TRACE_PRO_ANY(csa, wcb_bt_put);
@@ -92,8 +91,7 @@ bt_rec_ptr_t bt_put(gd_region *reg, int4 block)
 			bt->killtn = lcl_tn;
 			insqt((que_ent_ptr_t)bt, (que_ent_ptr_t)hdr);
 			th = (th_rec_ptr_t)remqh((que_ent_ptr_t)csa->th_base);
-			if (EMPTY_QUEUE == (sm_long_t)th)
+			assertpro(EMPTY_QUEUE != (sm_long_t)th);
-				GTMASSERT;
 			break;
 		}
 		if (bt->blk == block)
@@ -114,8 +112,7 @@ bt_rec_ptr_t bt_put(gd_region *reg, int4 block)
 			assert(in_wcs_recover || (bt->tn < lcl_tn) || (jgbl.forw_phase_recovery && !JNL_ENABLED(csa)));
 			q0 = (bt_rec_ptr_t)((sm_uc_ptr_t)bt + bt->tnque.fl);
 			th = (th_rec_ptr_t)remqt((que_ent_ptr_t)((sm_uc_ptr_t)q0 + SIZEOF(th->tnque)));
-			if (EMPTY_QUEUE == (sm_long_t)th)
+			assertpro(EMPTY_QUEUE != (sm_long_t)th);
-				GTMASSERT;
 			break;
 		}
 		if (0 == bt->blkque.fl)

sr_port/bt_refresh.c

@@ -46,7 +46,7 @@ void bt_refresh(sgmnt_addrs *csa, boolean_t init)
 			insqt((que_ent_ptr_t)((sm_uc_ptr_t)ptr + (2 * SIZEOF(sm_off_t))), (que_ent_ptr_t)csa->th_base);
 		}
 	}
-	((th_rec *)((uchar_ptr_t)csa->th_base + csa->th_base->tnque.fl))->tn = csa->ti->curr_tn - 1;
+	SET_OLDEST_HIST_TN(csa, csa->ti->curr_tn - 1);
 	csa->ti->mm_tn = 0;
 	return;
 }

sr_port/bx_boolop.c

@@ -1,6 +1,6 @@
 /****************************************************************
  *								*
- *	Copyright 2001, 2012 Fidelity Information Services, Inc	*
+ *	Copyright 2001, 2013 Fidelity Information Services, Inc	*
  *								*
  *	This source code contains the intellectual property	*
  *	of its copyright holder(s), and is made available	*
@@ -10,20 +10,58 @@
  ****************************************************************/
 
 #include "mdef.h"
+#include "cmd_qlf.h"
 #include "compiler.h"
 #include "opcode.h"
 #include "mdq.h"
 #include "mmemory.h"
-#include "emit_code.h"
+#include <emit_code.h>
 #include "fullbool.h"
 
 LITREF		octabstruct	oc_tab[];
 
+GBLREF boolean_t		run_time;
+GBLREF command_qualifier	cmd_qlf;
+
+#define STOTEMP_IF_NEEDED(REF0, I, T1, OPND)											\
+{	/* Input:														\
+	 * --- REF0:	a boolean triple, which may have either 1 input (OC_COBOOL) or 2 (other opcodes).			\
+	 * --- I:	whichever operand of REF0 we are STOTEMPing								\
+	 * --- T1:	STOTEMP triple. NOOPed if not needed									\
+	 * --- OPND:	operand referring to value we need need to pass as input into boolean operation				\
+	 * If OPND refers to a variable (OC_VAR), we need to STOTEMP it to protect it from subsequent side effects.		\
+	 * If it refers to a literal, and dynamic literals are enabled, we need to insert an OC_LITC anyway. Doing it		\
+	 * here in bx_boolop is convenient and ensures the OC_LITC is not skipped at run time.					\
+	 */															\
+	assert(TRIP_REF == OPND.oprclass);											\
+	switch (OPND.oprval.tref->opcode)											\
+	{															\
+		case OC_VAR:													\
+			T1->opcode = OC_STOTEMP;										\
+			T1->operand[0] = OPND;											\
+			REF0->operand[I] = put_tref(T1);									\
+			break;													\
+		case OC_LIT:													\
+			if (!run_time && (cmd_qlf.qlf & CQ_DYNAMIC_LITERALS))							\
+			{													\
+				T1->opcode = OC_LITC;										\
+				T1->operand[0] = OPND;										\
+				REF0->operand[I] = put_tref(T1);								\
+				break;												\
+			}													\
+		default:													\
+			T1->opcode = OC_NOOP;											\
+			T1->operand[0].oprclass = NO_REF;									\
+			REF0->operand[I] = put_tref(OPND.oprval.tref);								\
+	}															\
+}
+
 void bx_boolop(triple *t, boolean_t jmp_type_one, boolean_t jmp_to_next, boolean_t sense, oprtype *addr)
 {
 	boolean_t	expr_fini;
-	oprtype		*i, *p;
+	oprtype		*adj_addr, *i, *p;
-	triple		*ref0, *ref1, *t0, *t1;
+	tbp		*tripbp;
+	triple		*ref0, *ref1, *ref2, *t0, *t1;
 	DCL_THREADGBL_ACCESS;
 
 	SETUP_THREADGBL_ACCESS;
@@ -35,77 +73,93 @@ void bx_boolop(triple *t, boolean_t jmp_type_one, boolean_t jmp_to_next, boolean
 		*p = put_tjmp(t);
 	} else
 		p = addr;
-	if (GTM_BOOL == TREF(gtm_fullbool) || !TREF(saw_side_effect))
+	if (!TREF(saw_side_effect) || ((OLD_SE == TREF(side_effect_handling)) && (GTM_BOOL == TREF(gtm_fullbool))))
 	{	/* nice simple short circuit */
 		assert(NULL == TREF(boolchain_ptr));
 		bx_tail(t->operand[0].oprval.tref, jmp_type_one, p);
 		bx_tail(t->operand[1].oprval.tref, sense, addr);
-	} else
+		t->opcode = OC_NOOP;
-	{	/* got a side effect and don't want them short circuited - this violates info hiding big-time
+		t->operand[0].oprclass = t->operand[1].oprclass = NO_REF;
-		 * This code relies on the original technique of setting up a jump ladder
+		return;
-		 * then it changes the jumps into stotemps and creates a new ladder using the saved evaluations
+	}
-		 * for the relocated jumps to work with
+	/* got a side effect and don't want them short circuited */
-		 * The most interesting part is getting the addresses for the new jump operands (targets)
+	/* This code violates info hiding big-time and relies on the original technique of setting up a jump ladder
-		 * In theory we could turn this technique on and off around each side effect, but that's even more
+	 * then it changes the jumps into stotemps and creates a new ladder using the saved evaluations
-		 * complicated, requiring additional instructions, and we don't predict the typical boolean expression
+	 * for the relocated jumps to use for controlling conditional transfers, When the stotemps reference mvals,
-		 * has enough subexpressions to justify the extra trouble, although the potential pay-back would be to
+	 * they are optimized away when possible. The most interesting part is getting the addresses for the new jump
-		 * avoid unnecessary global references - again not expecting that many in a typical boolean expresion
+	 * operands (targets) - see comment below. In theory we could turn this technique on and off around each side effect,
-		 */
+	 * but that's even more complicated, requiring additional instructions, and we don't predict the typical boolean
-		assert(TREF(shift_side_effects));
+	 * expression has enough subexpressions to justify the extra trouble, although the potential pay-back would be to
+	 * avoid unnecessary global references - again, not expecting that many in a typical boolean expresion.
+	 */
+	assert(TREF(shift_side_effects));
+	if (expr_fini = (NULL == TREF(boolchain_ptr)))				/* NOTE assignment */
+	{									/* initialize work on boolean section of the AST */
+		TREF(boolchain_ptr) = &(TREF(boolchain));
+		dqinit(TREF(boolchain_ptr), exorder);
 		t0 = t->exorder.fl;
-		if (expr_fini = (NULL == TREF(boolchain_ptr)))			/* NOTE assignment */
+		if (NULL == TREF(bool_targ_ptr))
-		{
+		{								/* first time - set up anchor */
-			if (OC_BOOLFINI == t0->opcode)
+			TREF(bool_targ_ptr) = &(TREF(bool_targ_anchor));	/* mcalloc won't persist over multiple complies */
-			{	/* ex_tail wraps bools that produce a value with OC_BOOLINIT and OC_BOOLFINI */
+			dqinit(TREF(bool_targ_ptr), que);
-				assert(OC_COMVAL == t0->exorder.fl->opcode);
+		} else								/* queue should be empty */
-				assert(TRIP_REF == t0->operand[0].oprclass);
+			assert((TREF(bool_targ_ptr) == (TREF(bool_targ_ptr))->que.fl)
-			} else
+				&& (TREF(bool_targ_ptr) == (TREF(bool_targ_ptr))->que.bl));
-				assert(((OC_NOOP == t0->opcode) && (t0 == TREF(curtchain)))
+		/* ex_tail wraps bools that produce a value with OC_BOOLINIT (clr) and OC_BOOLFINI (set) */
-					|| (oc_tab[t0->opcode].octype & OCT_BOOL));
+		assert((OC_BOOLFINI != t0->opcode)
-			TREF(boolchain_ptr) = &(TREF(boolchain));
+			|| ((OC_COMVAL == t0->exorder.fl->opcode) && (TRIP_REF == t0->operand[0].oprclass)));
-			dqinit(TREF(boolchain_ptr), exorder);
+	}
+	for (i = t->operand; i < ARRAYTOP(t->operand); i++)
+	{
+		assert(NULL != TREF(boolchain_ptr));
+		t1 = i->oprval.tref;
+		if (&(t->operand[0]) == i)
+			bx_tail(t1, jmp_type_one, p);				/* do normal transform */
+		else
+		{	/* operand[1] */
+			bx_tail(t1, sense, addr);				/* do normal transform */
+			if (!expr_fini)
+				break;						/* only need to relocate last operand[1] */
 		}
-		for (i = t->operand; i < ARRAYTOP(t->operand); i++)
+		if (OC_NOOP == t1->opcode)
-		{
+		{	/* the technique of sprinkling noops means fishing around for the actual instruction */
-			t1 = i->oprval.tref;
+			do
-			if (&(t->operand[0]) == i)
+			{
-				bx_tail(t1, jmp_type_one, p);
+				t1 = t1->exorder.bl;
-			else
+				assert(TREF(curtchain) != t1->exorder.bl);
-			{	/* operand[1] */
+			} while (OC_NOOP == t1->opcode);
-				bx_tail(t1, sense, addr);
+			if ((oc_tab[t1->opcode].octype & OCT_JUMP) && (OC_JMPTSET != t1->opcode) && (OC_JMPTCLR != t1->opcode))
-				if (!expr_fini)
+				t1 = t1->exorder.bl;
-					break;					/* only need to relocate last operand[1] */
-			}
 			if (OC_NOOP == t1->opcode)
-			{	/* the technique of sprinkling noops means fishing around for the actual instruction */
+			{
-				do
+				for (t1 = i->oprval.tref; OC_NOOP == t1->opcode; t1 = t1->exorder.fl)
-				{
+					assert(TREF(curtchain) != t1->exorder.fl);
-					t1 = t1->exorder.bl;
-				} while (OC_NOOP == t1->opcode);
-				if (oc_tab[t1->opcode].octype & OCT_JUMP)
-					t1 = t1->exorder.bl;
-				else
-				{
-					for (t1 = i->oprval.tref; OC_NOOP == t1->opcode; t1 = t1->exorder.fl)
-						;
-				}
 			}
-			assert(NULL != TREF(boolchain_ptr));
+		}
-			switch (t1->opcode)
+		assert(OC_NOOP != t1->opcode);
-			{							/* time to subvert the original jump ladder entry */
+		assert((oc_tab[t1->exorder.fl->opcode].octype & OCT_JUMP)
+			||(OC_JMPTSET != t1->exorder.fl->opcode) || (OC_JMPTCLR != t1->exorder.fl->opcode));
+		ref0 = maketriple(t1->opcode);					/* copy operation for place in new ladder */
+		ref1 = (TREF(boolchain_ptr))->exorder.bl;			/* common setup for above op insert */
+		switch (t1->opcode)
+		{								/* time to subvert original jump ladder entry */
 			case OC_COBOOL:
 				/* insert COBOOL and copy of following JMP in boolchain; overlay them with STOTEMP and NOOP  */
-				assert(oc_tab[t1->exorder.fl->opcode].octype & OCT_JUMP);
+				assert(TRIP_REF == t1->operand[0].oprclass);
-				ref0 = maketriple(OC_COBOOL);			/* coerce later while pulling it out of temp */
-				ref0->operand[0] = put_tref(t1);
-				ref1 = (TREF(boolchain_ptr))->exorder.bl;
 				dqins(ref1, exorder, ref0);
-				t1->opcode = OC_STOTEMP;			/* save the value instead of coercing now */
+				if (oc_tab[t1->operand[0].oprval.tref->opcode].octype & OCT_MVAL)
+				{						/* do we need a STOTEMP? */
+					STOTEMP_IF_NEEDED(ref0, 0, t1, t1->operand[0]);
+				} else
+				{						/* make it an mval instead of COBOOL now */
+					t1->opcode = OC_COMVAL;
+					ref0->operand[0] = put_tref(t1);	/* new COBOOL points to this OC_COMVAL  */
+				}
 				t1 = t1->exorder.fl;
-				ref0 = maketriple(t1->opcode);			/* create new jump on result of coerce */
+				ref0 = maketriple(t1->opcode);			/* create new jmp on result of coerce */
 				ref0->operand[0] = t1->operand[0];
-				t1->operand[0].oprclass = NOCLASS;
+				t1->opcode = OC_NOOP;				/* wipe out original jmp */
-				t1->opcode = OC_NOOP;				/* wipe out original jump */
+				t1->operand[0].oprclass = NO_REF;
 				break;
 			case OC_CONTAIN:
 			case OC_EQU:
@@ -114,85 +168,117 @@ void bx_boolop(triple *t, boolean_t jmp_type_one, boolean_t jmp_to_next, boolean
 			case OC_PATTERN:
 			case OC_SORTS_AFTER:
 				/* insert copies of orig OC and following JMP in boolchain & overly originals with STOTEMPs */
-				assert(oc_tab[t1->exorder.fl->opcode].octype & OCT_JUMP);
 				assert(TRIP_REF == t1->operand[0].oprclass);
 				assert(TRIP_REF == t1->operand[1].oprclass);
-				ref0 = maketriple(t1->opcode);			/* copy operands with the stotemps as args */
-				ref0->operand[0] = put_tref(t1);
-				ref0->operand[1] = put_tref(t1->exorder.fl);
-				ref1 = (TREF(boolchain_ptr))->exorder.bl;
 				dqins(ref1, exorder, ref0);
-				t1->opcode = OC_STOTEMP;			/* overlay the original op with 1st stotemp */
+				STOTEMP_IF_NEEDED(ref0, 0, t1, t1->operand[0]);
+				ref1 = t1;
 				t1 = t1->exorder.fl;
-				ref0 = maketriple(t1->opcode);			/* copy jmp */
+				ref2 = maketriple(t1->opcode);			/* copy jmp */
-				ref0->operand[0] = t1->operand[0];
+				ref2->operand[0] = t1->operand[0];
-				t1->operand[0] = t1->exorder.bl->operand[1];
+				STOTEMP_IF_NEEDED(ref0, 1, t1, ref1->operand[1]);
-				t1->opcode = OC_STOTEMP;			/* overlay jmp with 2nd stotemp */
+				if (OC_NOOP == ref1->opcode)			/* does op[0] need cleanup? */
+					ref1->operand[0].oprclass = ref1->operand[1].oprclass = NO_REF;
+				ref0 = ref2;
 				break;
 			case OC_JMPTSET:
 			case OC_JMPTCLR:
-				/* move copy of jmp to boolchain and NOOP it */
+										/* move copy of jmp to boolchain and NOOP it */
-				ref0 = maketriple(t1->opcode);
+				ref0->operand[0] = t1->operand[0];		/* new jmpt gets old target */
-				ref0->operand[0] = t1->operand[0];
+				ref2 = maketriple(OC_NOOP);			/* insert a NOOP in new chain inplace of COBOOL */
-				t1->operand[0].oprclass = NOCLASS;
+				dqins(ref1, exorder, ref2);
-				t1->opcode = OC_NOOP;				/* wipe out original jump */
+				t1->opcode = OC_NOOP;				/* wipe out original jmp */
+				t1->operand[0].oprclass = NO_REF;
 				break;
 			default:
-				GTMASSERT;
+				assertpro(FALSE);
-			}
-			if (jmp_to_next)					/* mark target for later adjustment */
-					ref0->operand[1].oprval.tref = ref0->operand[0].oprval.tref;
-			ref1 = (TREF(boolchain_ptr))->exorder.bl;
-			dqins(ref1, exorder, ref0);
-		}
-		if (expr_fini)
-		{	/* time to deal with new jump ladder */
-			assert(NULL != TREF(boolchain_ptr));
-			t0 = t0->exorder.bl;
-			assert(oc_tab[t0->opcode].octype & OCT_BOOL);
-			assert(t0 == t);
-			dqadd(t0, TREF(boolchain_ptr), exorder);			/* insert the new jump ladder */
-			ref0 = (TREF(boolchain_ptr))->exorder.bl->exorder.fl;
-			if (ref0 == TREF(curtchain))
-			{
-				newtriple(OC_NOOP);
-				ref0 = (TREF(curtchain))->exorder.bl;
-			}
-			assert(ref0);
-			t0 = t->exorder.fl;
-			if ((OC_JMPTSET != t0->opcode) && (OC_JMPTCLR != t0->opcode))
-				t0 = t0->exorder.fl;
-			for (; (t0 != TREF(curtchain)) && oc_tab[t0->opcode].octype & OCT_JUMP; t0 = t1)
-			{	/* check for jumps with targets */
-				assert(INDR_REF == t0->operand[0].oprclass);
-				t1 = t0->exorder.fl;
-				if (oc_tab[t1->opcode].octype & OCT_BOOL)
-					t1 = ref1 = t1->exorder.fl;
-				else
-				{
-					if ((OC_JMPTSET == t1->opcode) || (OC_JMPTCLR == t1->opcode))
-						ref1 = t1;
-					else
-						break;
-				}
-				if (t0->operand[1].oprval.tref == t0->operand[0].oprval.tref)
-				{	/* adjust relocated jump to "next" */
-					if (oc_tab[ref1->opcode].octype & OCT_JUMP)
-						ref1 = ref1->exorder.fl;
-					if ((ref1 == TREF(curtchain)
-						|| (t == t0->operand[0].oprval.tref->exorder.fl)))
-							ref1 = ref0;
-					assert((OC_NOOP == ref1->opcode) || (OC_BOOLFINI == ref1->opcode)
-						|| (OC_COMVAL == ref1->opcode) || (oc_tab[ref1->opcode].octype & OCT_BOOL));
-					t0->operand[0] = put_tjmp(ref1);
-					t0->operand[1].oprval.tref = NULL;
-				} else if (TJMP_REF == t0->operand[0].oprval.indr->oprclass)
-					t0->operand[0] = put_tjmp(ref0);	/* adjust jump to "addr" */
-			}
-			TREF(boolchain_ptr) = NULL;
 		}
+		assert((OC_STOTEMP == t1->opcode) || (OC_NOOP == t1->opcode) || (OC_COMVAL == t1->opcode)
+			  || (OC_LITC == t1->opcode));
+		assert(oc_tab[ref0->opcode].octype & OCT_JUMP);
+		ref1 = (TREF(boolchain_ptr))->exorder.bl;
+		dqins(ref1, exorder, ref0);					/* common insert for new jmp */
+	}
+	assert(oc_tab[t->opcode].octype & OCT_BOOL);
+	t->opcode = OC_NOOP;							/* wipe out the original boolean op */
+	t->operand[0].oprclass = t->operand[1].oprclass = NO_REF;
+	tripbp = &t->jmplist;							/* borrow jmplist to track jmp targets */
+	assert(NULL == tripbp->bpt);
+	assert((tripbp == tripbp->que.fl) && (tripbp == tripbp->que.bl));
+	tripbp->bpt = jmp_to_next ? (TREF(boolchain_ptr))->exorder.bl : ref0;	/* point op triple at op[1] position or op[0] */
+	dqins(TREF(bool_targ_ptr), que, tripbp);				/* queue jmplist for clean-up */
+	if (!expr_fini)
+		return;
+	/* time to deal with new jump ladder */
+	assert(NULL != TREF(boolchain_ptr));
+	assert(NULL != TREF(bool_targ_ptr));
+	assert(TREF(bool_targ_ptr) != (TREF(bool_targ_ptr))->que.fl);
+	assert(t0->exorder.bl == t);
+	assert(t0 == t->exorder.fl);
+	dqadd(t, TREF(boolchain_ptr), exorder);					/* insert the new jump ladder */
+	ref0 = (TREF(boolchain_ptr))->exorder.bl->exorder.fl;
+	t0 = t->exorder.fl;
+	if (ref0 == TREF(curtchain))
+	{									/* add a safe target */
+		newtriple(OC_NOOP);
+		ref0 = (TREF(curtchain))->exorder.bl;
+	}
+	assert((OC_COBOOL == t0->opcode) ||(OC_JMPTSET != t0->opcode) || (OC_JMPTCLR != t0->opcode)) ;
+	t0 = t0->exorder.fl;
+	assert(oc_tab[t0->opcode].octype & OCT_JUMP);
+	for (; (t0 != ref0) && oc_tab[t0->opcode].octype & OCT_JUMP; t0 = t0->exorder.fl)
+	{									/* process replacement jmps */
+		adj_addr = &t0->operand[0];
+		assert(INDR_REF == adj_addr->oprclass);
+		if (NULL != (t1 = (adj_addr = adj_addr->oprval.indr)->oprval.tref))
+		{								/*  need to adjust target; NOTE assignments above */
+			if (OC_BOOLFINI != t1->opcode)
+			{							/* not past the end of the new chain */
+				assert(TJMP_REF == adj_addr->oprclass);
+				if ((t == t1) || (t1 == ref0))
+					ref1 = ref0;				/* adjust to end of boolean expression */
+				else
+				{						/* old target should have jmplist entry */
+					/* from the jmp jmplisted in the old target we move past the next
+					 * test (or NOOP) and jmp which correspond to the old target and pick
+					 * the subsequent test (or NOOP) and jmp which correspond to those that originally followed
+					 * the logic after the old target and are therefore the appropriate new target for this jmp
+					 */
+					assert(OC_NOOP == t1->opcode);
+					assert(&(t1->jmplist) != t1->jmplist.que.fl);
+					assert(NULL != t1->jmplist.bpt);
+					assert(oc_tab[t1->jmplist.bpt->opcode].octype & OCT_JUMP);
+					ref1 = t1->jmplist.bpt->exorder.fl;
+					assert((oc_tab[ref1->opcode].octype & OCT_BOOL) || (OC_NOOP == ref1->opcode));
+					assert(oc_tab[ref1->exorder.fl->opcode].octype & OCT_JUMP);
+					ref1 = ref1->exorder.fl->exorder.fl;
+					assert((oc_tab[ref1->opcode].octype & OCT_BOOL) || (OC_BOOLFINI == ref1->opcode)
+						|| ((OC_NOOP == ref1->opcode) && ((OC_JMPTCLR == ref1->exorder.fl->opcode)
+						|| (OC_JMPTSET == ref1->exorder.fl->opcode)
+						|| (TREF(curtchain) == ref1->exorder.fl))));
+				}
+				t0->operand[0] = put_tjmp(ref1);		/* no indrection simplifies later interations */
+			}
+		}
+		t0 = t0->exorder.fl;
+		if ((OC_BOOLFINI == t0->opcode) || (TREF(curtchain) == t0->exorder.fl))
+			break;
+		assert((oc_tab[t0->opcode].octype & OCT_BOOL)
+			|| (OC_JMPTSET == t0->exorder.fl->opcode) || (OC_JMPTCLR == t0->exorder.fl->opcode));
+	}
+	dqloop(TREF(bool_targ_ptr), que, tripbp)				/* clean up borrowed jmplist entries */
+	{
+		dqdel(tripbp, que);
+		tripbp->bpt = NULL;
+	}
+	assert((TREF(bool_targ_ptr) == (TREF(bool_targ_ptr))->que.fl)
+		&& (TREF(bool_targ_ptr) == (TREF(bool_targ_ptr))->que.bl));
+	TREF(boolchain_ptr) = NULL;
+	if (TREF(expr_start) != TREF(expr_start_orig))
+	{									/* inocculate against an unwanted GVRECTARG */
+		ref0 = maketriple(OC_NOOP);
+		dqins(TREF(expr_start), exorder, ref0);
+		TREF(expr_start) = ref0;
 	}
-	t->opcode = OC_NOOP;
-	t->operand[0].oprclass = t->operand[1].oprclass = NOCLASS;
 	return;
 }

sr_port/bx_tail.c

@@ -1,6 +1,6 @@
 /****************************************************************
  *								*
- *	Copyright 2001, 2011 Fidelity Information Services, Inc	*
+ *	Copyright 2001, 2012 Fidelity Information Services, Inc	*
  *								*
  *	This source code contains the intellectual property	*
  *	of its copyright holder(s), and is made available	*
@@ -45,7 +45,7 @@ void bx_tail(triple *t, boolean_t sense, oprtype *addr)
 	assert((1 & sense) == sense);
 	assert(oc_tab[t->opcode].octype & OCT_BOOL);
 	assert(TRIP_REF == t->operand[0].oprclass);
-	assert((TRIP_REF == t->operand[1].oprclass) || (NOCLASS == t->operand[1].oprclass));
+	assert((TRIP_REF == t->operand[1].oprclass) || (NO_REF == t->operand[1].oprclass));
 	switch (t->opcode)
 	{
 	case OC_COBOOL:
@@ -64,7 +64,7 @@ void bx_tail(triple *t, boolean_t sense, oprtype *addr)
 	case OC_COM:
 		bx_tail(t->operand[0].oprval.tref, !sense, addr);
 		t->opcode = OC_NOOP;
-		t->operand[0].oprclass = 0;
+		t->operand[0].oprclass = NO_REF;
 		return;
 	case OC_NEQU:
 		sense = !sense;

sr_port/cache_cleanup.c

@@ -13,7 +13,7 @@
 #include "objlabel.h"
 #include "cache.h"
 #include "hashtab_objcode.h"
-#include "rtnhdr.h"
+#include <rtnhdr.h>
 #include "stack_frame.h"
 #include "cache_cleanup.h"
 

sr_port/cache_put.c

@@ -16,7 +16,7 @@
 #include "hashtab_objcode.h"
 #include "cachectl.h"
 #include "cacheflush.h"
-#include "rtnhdr.h"
+#include <rtnhdr.h>
 #include "gtm_text_alloc.h"
 #include "io.h"