Corrected the "extresist" node merge routine to not merge away the

ResNodeAtOrigin node, but to instead move it to the remaining valid
node.

.github/workflows/appimage.yml

@@ -1,28 +0,0 @@
-on:
-  push:
-    tags:
-      - "*"
-
-name: CI-appimage
-
-jobs:
-  build_appimage:
-    name: Build AppImage
-    runs-on: ubuntu-20.04
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v4
-      - name: Get the version
-        id: get_version
-        run: |
-          export VERSION_NUM=$(ruby -e "print '$GITHUB_REF'.split('/')[2]")
-          echo ::set-output name=value::${VERSION_NUM}
-      - name: Build project
-        run: |
-          cd appimage
-          make
-          cp Magic-x86_64.AppImage /tmp/Magic-${{ steps.get_version.outputs.value }}-x86_64.AppImage
-      - name: Upload Release Asset
-        uses: softprops/action-gh-release@v1
-        with:
-          files: /tmp/Magic-${{ steps.get_version.outputs.value }}-x86_64.AppImage

.github/workflows/appimage10.yml

@@ -0,0 +1,170 @@
+on:
+  push:
+    tags:
+      - "*"
+  workflow_dispatch:
+
+name: CI-appimage10
+
+env:
+  APPIMAGETOOL_DOWNLOAD_URL: https://github.com/AppImage/appimagetool/releases/download/continuous/appimagetool-x86_64.AppImage
+
+jobs:
+  build_appimage10:
+    name: Build AppImage EL10
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write # action-gh-release
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 149 # enough to cover between tags
+          #fetch-tags: true # this should work see actions/checkout~issue#1471
+
+      - name: Get the version
+        id: get_version
+        run: |
+          git show -s
+          version=$(cat VERSION) # 8.9.999
+          version_tstamp=$(git show -s "--format=%cs" | tr -d '-') # YYYYMMDD
+          version_hash=$(git show -s "--format=%h") # abcdefg
+          version_num=$(ruby -e "print '$GITHUB_REF'.split('/')[2]") # legacy version method: master
+          echo "version=${version}"
+          echo "version_tstamp=${version_tstamp}"
+          echo "version_hash=${version_hash}"
+          echo "version_num=${version_num}"
+          VERSION_NUM="${version}~${version_tstamp}~${version_hash}"
+          echo "VERSION_NUM=${VERSION_NUM}" >> $GITHUB_ENV
+          echo "MAGIC_APPIMAGE_OUTPUT_FILENAME=Magic-${VERSION_NUM}-x86_64-EL10.AppImage" >> $GITHUB_ENV
+          # Is this GHA being run due to a push-on-tag ?  if so we make a GitHub release, otherwise we just publish artifact
+          github_tag=$(echo -n "$GITHUB_REF" | sed -e 's#refs/tags/##') # 8.9.999
+          echo "github_tag=$github_tag"
+          if echo -n "$GITHUB_REF" | egrep -q "^refs/tags/" # check prefix
+          then
+            if [ -n "$github_tag" ]
+            then
+              echo "MY_GITHUB_TAG=${github_tag}" >> $GITHUB_ENV
+            fi
+          fi
+
+      - name: Build project
+        run: |
+          cd appimage/10
+          make
+
+          ln -v Magic-x86_64.AppImage "${MAGIC_APPIMAGE_OUTPUT_FILENAME}"
+          ls -l *.AppImage
+          sha256sum *.AppImage
+          pwd
+
+      - name: Create RELEASE-NOTES.txt
+        run: |
+          cd appimage/10
+          # Find the last tag (that does not match the current GITHUB_REF)
+          echo GITHUB_REF=$GITHUB_REF
+          echo GITHUB_SHA=$GITHUB_SHA
+          # GitHub CI is a shallow checkout by default (just the files needed to build)
+          # but we also want history back to next tag, see fetch-tags/fetch-depth actions/checkout~issue#1471
+          if [[ "$GITHUB_REF" =~ ^refs/tags/ ]]
+          then
+            # remove only if ref of tag (to avoid conflict during fetch)
+            git update-ref -d $GITHUB_REF
+            echo git_update_ref_exitstatus=$?
+          fi
+          set +e
+          git fetch --tags --prune --no-recurse-submodules --depth=149 origin +$GITHUB_SHA # fetch-tags: true # is broken
+          echo git_fetch_exitstatus=$?
+          git_show_ref=$(git show-ref --hash $GITHUB_REF) # get tagcommit hash
+          git_show_ref_exitstatus=$?
+          echo git_show_ref_exitstatus=$git_show_ref_exitstatus
+          echo git_show_ref=$git_show_ref
+          git_rev_list=$(git rev-list -n1 $GITHUB_REF) # get commit hash
+          git_rev_list_exitstatus=$?
+          echo git_rev_list_exitstatus=$git_rev_list_exitstatus
+          echo git_rev_list=$git_rev_list
+          set -e
+          test "$git_show_ref" = "$GITHUB_SHA" || test "$git_rev_list" = "$GITHUB_SHA" # check we got the ref back (or fail CI)
+          git_describe=$(git describe --tags $GITHUB_SHA | sed -e 's#\-\([0-9]\+\-g\)#\+\1#') # /-\d+-g/
+          echo git_describe=$git_describe
+
+          # RELEASE-NOTES-EL10.txt
+          echo "### ${MAGIC_APPIMAGE_OUTPUT_FILENAME} commit ${git_describe}" | sed -e 's#~#\\~#g' > RELEASE-NOTES-EL10.txt
+          echo "" >> RELEASE-NOTES-EL10.txt
+          echo "This release is based on EL10 (AlmaLinux10), the AppImage format is designed to run on a wide range of Linux distributions." >> RELEASE-NOTES-EL10.txt
+          echo "" >> RELEASE-NOTES-EL10.txt
+          echo "See documentation at https://github.com/${GITHUB_REPOSITORY}/blob/${GITHUB_SHA:0:8}/appimage/10/README.md" >> RELEASE-NOTES-EL10.txt
+          echo "" >> RELEASE-NOTES-EL10.txt
+          length_info=$(stat "--format=%s bytes" "${MAGIC_APPIMAGE_OUTPUT_FILENAME}")
+          sha256_info=$(sha256sum "${MAGIC_APPIMAGE_OUTPUT_FILENAME}" | cut -d ' ' -f1)
+          echo "|   |   |" >> RELEASE-NOTES-EL10.txt
+          echo "| :-------- | :------ |" >> RELEASE-NOTES-EL10.txt
+          echo "| File Name | ${MAGIC_APPIMAGE_OUTPUT_FILENAME} |" | sed -e 's#~#\\~#g' >> RELEASE-NOTES-EL10.txt
+          echo "| File Length | ${length_info} |" >> RELEASE-NOTES-EL10.txt
+          echo "| File SHA256 | ${sha256_info} |" >> RELEASE-NOTES-EL10.txt
+          echo "" >> RELEASE-NOTES-EL10.txt
+
+          # RELEASE-NOTES-CL.txt
+          set +e # allow this to fail to empty string
+          git_previous_tag=$(git describe --tags --abbrev=0 $(git rev-list --tags --skip=1 --max-count=1))
+          echo git_previous_tag=$git_previous_tag
+          set -e
+          if [ -n "${git_previous_tag}" ]
+          then
+              echo "### Change Log (since previous tag):" > RELEASE-NOTES-CL.txt
+              echo "\`\`\`" >> RELEASE-NOTES-CL.txt
+              git log --oneline --no-color --no-decorate "refs/tags/${git_previous_tag}..${GITHUB_REF}" >> RELEASE-NOTES-CL.txt
+              echo "\`\`\`" >> RELEASE-NOTES-CL.txt
+          else
+              echo "### Change Log (last commit only):" > RELEASE-NOTES-CL.txt
+              echo "\`\`\`" >> RELEASE-NOTES-CL.txt
+              git log --oneline -n1 --no-color --no-decorate "${GITHUB_REF}" >> RELEASE-NOTES-CL.txt
+              echo "\`\`\`" >> RELEASE-NOTES-CL.txt
+          fi
+          echo "" >> RELEASE-NOTES-CL.txt
+
+          #echo "### Build Info:" > RELEASE-NOTES-BI.txt
+          # FIXME extract package version info and DSO symvers into RELEASE-NOTES.txt
+          #echo "" >> RELEASE-NOTES-BI.txt
+
+          cat RELEASE-NOTES-CL.txt >> RELEASE-NOTES-EL10.txt
+          cat RELEASE-NOTES-EL10.txt
+
+          # RELEASE-NOTES-DOCS.txt
+          echo "See documentation at https://github.com/${GITHUB_REPOSITORY}/blob/${GITHUB_SHA:0:8}/appimage/7/README.md" >> RELEASE-NOTES-DOCS.txt
+          echo "See documentation at https://github.com/${GITHUB_REPOSITORY}/blob/${GITHUB_SHA:0:8}/appimage/8/README.md" >> RELEASE-NOTES-DOCS.txt
+          echo "See documentation at https://github.com/${GITHUB_REPOSITORY}/blob/${GITHUB_SHA:0:8}/appimage/9/README.md" >> RELEASE-NOTES-DOCS.txt
+          echo "See documentation at https://github.com/${GITHUB_REPOSITORY}/blob/${GITHUB_SHA:0:8}/appimage/10/README.md" >> RELEASE-NOTES-DOCS.txt
+
+          # RELEASE-NOTES-GH.txt (this is shared for all AppImage for one tag)
+          echo "### commit ${git_describe}" | sed -e 's#~#\\~#g' > RELEASE-NOTES-GH.txt
+          if [[ "$GITHUB_REF" =~ ^refs/tags/ ]]
+          then
+            # show tag annotation with tags like before
+            git tag  --cleanup=strip "--format=%(contents)" -n "${GITHUB_REF:10}" | sed -e 's#\([~|]\)#\\\1#g' >> RELEASE-NOTES-GH.txt
+          fi
+          echo "" >> RELEASE-NOTES-GH.txt
+          cat RELEASE-NOTES-DOCS.txt >> RELEASE-NOTES-GH.txt
+          cat RELEASE-NOTES-CL.txt >> RELEASE-NOTES-GH.txt
+
+          # Show in action/artifact output
+          echo "## RELEASE NOTES" >> $GITHUB_STEP_SUMMARY
+          echo "" >> $GITHUB_STEP_SUMMARY
+          cat RELEASE-NOTES-EL10.txt >> $GITHUB_STEP_SUMMARY
+
+      - name: Upload Release Asset
+        if: ${{ env.MY_GITHUB_TAG != '' }} # if: ${{ github.ref_type == 'tag' }}
+        uses: softprops/action-gh-release@v2
+        with:
+          body_path: ${{ github.workspace }}/appimage/10/RELEASE-NOTES-GH.txt
+          files: |
+            ${{ github.workspace }}/appimage/10/${{env.MAGIC_APPIMAGE_OUTPUT_FILENAME}}
+            ${{ github.workspace }}/appimage/10/RELEASE-NOTES-EL10.txt
+
+      - name: Upload Artifact
+        #if: ${{ env.MY_GITHUB_TAG == '' }} # commented out to always upload
+        uses: actions/upload-artifact@v4
+        with:
+          name: ${{env.MAGIC_APPIMAGE_OUTPUT_FILENAME}}
+          path: |
+            ${{ github.workspace }}/appimage/10/${{env.MAGIC_APPIMAGE_OUTPUT_FILENAME}}

.github/workflows/appimage7.yml

@@ -0,0 +1,170 @@
+on:
+  push:
+    tags:
+      - "*"
+  workflow_dispatch:
+
+name: CI-appimage7
+
+env:
+  APPIMAGETOOL_DOWNLOAD_URL: https://github.com/AppImage/appimagetool/releases/download/continuous/appimagetool-x86_64.AppImage
+
+jobs:
+  build_appimage7:
+    name: Build AppImage EL7
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write # action-gh-release
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 149 # enough to cover between tags
+          #fetch-tags: true # this should work see actions/checkout~issue#1471
+
+      - name: Get the version
+        id: get_version
+        run: |
+          git show -s
+          version=$(cat VERSION) # 8.9.999
+          version_tstamp=$(git show -s "--format=%cs" | tr -d '-') # YYYYMMDD
+          version_hash=$(git show -s "--format=%h") # abcdefg
+          version_num=$(ruby -e "print '$GITHUB_REF'.split('/')[2]") # legacy version method: master
+          echo "version=${version}"
+          echo "version_tstamp=${version_tstamp}"
+          echo "version_hash=${version_hash}"
+          echo "version_num=${version_num}"
+          VERSION_NUM="${version}~${version_tstamp}~${version_hash}"
+          echo "VERSION_NUM=${VERSION_NUM}" >> $GITHUB_ENV
+          echo "MAGIC_APPIMAGE_OUTPUT_FILENAME=Magic-${VERSION_NUM}-x86_64-EL7.AppImage" >> $GITHUB_ENV
+          # Is this GHA being run due to a push-on-tag ?  if so we make a GitHub release, otherwise we just publish artifact
+          github_tag=$(echo -n "$GITHUB_REF" | sed -e 's#refs/tags/##') # 8.9.999
+          echo "github_tag=$github_tag"
+          if echo -n "$GITHUB_REF" | egrep -q "^refs/tags/" # check prefix
+          then
+            if [ -n "$github_tag" ]
+            then
+              echo "MY_GITHUB_TAG=${github_tag}" >> $GITHUB_ENV
+            fi
+          fi
+
+      - name: Build project
+        run: |
+          cd appimage/7
+          make
+
+          ln -v Magic-x86_64.AppImage "${MAGIC_APPIMAGE_OUTPUT_FILENAME}"
+          ls -l *.AppImage
+          sha256sum *.AppImage
+          pwd
+
+      - name: Create RELEASE-NOTES.txt
+        run: |
+          cd appimage/7
+          # Find the last tag (that does not match the current GITHUB_REF)
+          echo GITHUB_REF=$GITHUB_REF
+          echo GITHUB_SHA=$GITHUB_SHA
+          # GitHub CI is a shallow checkout by default (just the files needed to build)
+          # but we also want history back to next tag, see fetch-tags/fetch-depth actions/checkout~issue#1471
+          if [[ "$GITHUB_REF" =~ ^refs/tags/ ]]
+          then
+            # remove only if ref of tag (to avoid conflict during fetch)
+            git update-ref -d $GITHUB_REF
+            echo git_update_ref_exitstatus=$?
+          fi
+          set +e
+          git fetch --tags --prune --no-recurse-submodules --depth=149 origin +$GITHUB_SHA # fetch-tags: true # is broken
+          echo git_fetch_exitstatus=$?
+          git_show_ref=$(git show-ref --hash $GITHUB_REF) # get tagcommit hash
+          git_show_ref_exitstatus=$?
+          echo git_show_ref_exitstatus=$git_show_ref_exitstatus
+          echo git_show_ref=$git_show_ref
+          git_rev_list=$(git rev-list -n1 $GITHUB_REF) # get commit hash
+          git_rev_list_exitstatus=$?
+          echo git_rev_list_exitstatus=$git_rev_list_exitstatus
+          echo git_rev_list=$git_rev_list
+          set -e
+          test "$git_show_ref" = "$GITHUB_SHA" || test "$git_rev_list" = "$GITHUB_SHA" # check we got the ref back (or fail CI)
+          git_describe=$(git describe --tags $GITHUB_SHA | sed -e 's#\-\([0-9]\+\-g\)#\+\1#') # /-\d+-g/
+          echo git_describe=$git_describe
+
+          # RELEASE-NOTES-EL7.txt
+          echo "### ${MAGIC_APPIMAGE_OUTPUT_FILENAME} commit ${git_describe}" | sed -e 's#~#\\~#g' > RELEASE-NOTES-EL7.txt
+          echo "" >> RELEASE-NOTES-EL7.txt
+          echo "This release is based on EL7 (CentOS7), the AppImage format is designed to run on a wide range of Linux distributions." >> RELEASE-NOTES-EL7.txt
+          echo "" >> RELEASE-NOTES-EL7.txt
+          echo "See documentation at https://github.com/${GITHUB_REPOSITORY}/blob/${GITHUB_SHA:0:8}/appimage/7/README.md" >> RELEASE-NOTES-EL7.txt
+          echo "" >> RELEASE-NOTES-EL7.txt
+          length_info=$(stat "--format=%s bytes" "${MAGIC_APPIMAGE_OUTPUT_FILENAME}")
+          sha256_info=$(sha256sum "${MAGIC_APPIMAGE_OUTPUT_FILENAME}" | cut -d ' ' -f1)
+          echo "|   |   |" >> RELEASE-NOTES-EL7.txt
+          echo "| :-------- | :------ |" >> RELEASE-NOTES-EL7.txt
+          echo "| File Name | ${MAGIC_APPIMAGE_OUTPUT_FILENAME} |" | sed -e 's#~#\\~#g' >> RELEASE-NOTES-EL7.txt
+          echo "| File Length | ${length_info} |" >> RELEASE-NOTES-EL7.txt
+          echo "| File SHA256 | ${sha256_info} |" >> RELEASE-NOTES-EL7.txt
+          echo "" >> RELEASE-NOTES-EL7.txt
+
+          # RELEASE-NOTES-CL.txt
+          set +e # allow this to fail to empty string
+          git_previous_tag=$(git describe --tags --abbrev=0 $(git rev-list --tags --skip=1 --max-count=1))
+          echo git_previous_tag=$git_previous_tag
+          set -e
+          if [ -n "${git_previous_tag}" ]
+          then
+              echo "### Change Log (since previous tag):" > RELEASE-NOTES-CL.txt
+              echo "\`\`\`" >> RELEASE-NOTES-CL.txt
+              git log --oneline --no-color --no-decorate "refs/tags/${git_previous_tag}..${GITHUB_REF}" >> RELEASE-NOTES-CL.txt
+              echo "\`\`\`" >> RELEASE-NOTES-CL.txt
+          else
+              echo "### Change Log (last commit only):" > RELEASE-NOTES-CL.txt
+              echo "\`\`\`" >> RELEASE-NOTES-CL.txt
+              git log --oneline -n1 --no-color --no-decorate "${GITHUB_REF}" >> RELEASE-NOTES-CL.txt
+              echo "\`\`\`" >> RELEASE-NOTES-CL.txt
+          fi
+          echo "" >> RELEASE-NOTES-CL.txt
+
+          #echo "### Build Info:" > RELEASE-NOTES-BI.txt
+          # FIXME extract package version info and DSO symvers into RELEASE-NOTES.txt
+          #echo "" >> RELEASE-NOTES-BI.txt
+
+          cat RELEASE-NOTES-CL.txt >> RELEASE-NOTES-EL7.txt
+          cat RELEASE-NOTES-EL7.txt
+
+          # RELEASE-NOTES-DOCS.txt
+          echo "See documentation at https://github.com/${GITHUB_REPOSITORY}/blob/${GITHUB_SHA:0:8}/appimage/7/README.md" >> RELEASE-NOTES-DOCS.txt
+          echo "See documentation at https://github.com/${GITHUB_REPOSITORY}/blob/${GITHUB_SHA:0:8}/appimage/8/README.md" >> RELEASE-NOTES-DOCS.txt
+          echo "See documentation at https://github.com/${GITHUB_REPOSITORY}/blob/${GITHUB_SHA:0:8}/appimage/9/README.md" >> RELEASE-NOTES-DOCS.txt
+          echo "See documentation at https://github.com/${GITHUB_REPOSITORY}/blob/${GITHUB_SHA:0:8}/appimage/10/README.md" >> RELEASE-NOTES-DOCS.txt
+
+          # RELEASE-NOTES-GH.txt (this is shared for all AppImage for one tag)
+          echo "### commit ${git_describe}" | sed -e 's#~#\\~#g' > RELEASE-NOTES-GH.txt
+          if [[ "$GITHUB_REF" =~ ^refs/tags/ ]]
+          then
+            # show tag annotation with tags like before
+            git tag  --cleanup=strip "--format=%(contents)" -n "${GITHUB_REF:10}" | sed -e 's#\([~|]\)#\\\1#g' >> RELEASE-NOTES-GH.txt
+          fi
+          echo "" >> RELEASE-NOTES-GH.txt
+          cat RELEASE-NOTES-DOCS.txt >> RELEASE-NOTES-GH.txt
+          cat RELEASE-NOTES-CL.txt >> RELEASE-NOTES-GH.txt
+
+          # Show in action/artifact output
+          echo "## RELEASE NOTES" >> $GITHUB_STEP_SUMMARY
+          echo "" >> $GITHUB_STEP_SUMMARY
+          cat RELEASE-NOTES-EL7.txt >> $GITHUB_STEP_SUMMARY
+
+      - name: Upload Release Asset
+        if: ${{ env.MY_GITHUB_TAG != '' }} # if: ${{ github.ref_type == 'tag' }}
+        uses: softprops/action-gh-release@v2
+        with:
+          body_path: ${{ github.workspace }}/appimage/7/RELEASE-NOTES-GH.txt
+          files: |
+            ${{ github.workspace }}/appimage/7/${{env.MAGIC_APPIMAGE_OUTPUT_FILENAME}}
+            ${{ github.workspace }}/appimage/7/RELEASE-NOTES-EL7.txt
+
+      - name: Upload Artifact
+        #if: ${{ env.MY_GITHUB_TAG == '' }} # commented out to always upload
+        uses: actions/upload-artifact@v4
+        with:
+          name: ${{env.MAGIC_APPIMAGE_OUTPUT_FILENAME}}
+          path: |
+            ${{ github.workspace }}/appimage/7/${{env.MAGIC_APPIMAGE_OUTPUT_FILENAME}}

.github/workflows/appimage8.yml

@@ -0,0 +1,170 @@
+on:
+  push:
+    tags:
+      - "*"
+  workflow_dispatch:
+
+name: CI-appimage8
+
+env:
+  APPIMAGETOOL_DOWNLOAD_URL: https://github.com/AppImage/appimagetool/releases/download/continuous/appimagetool-x86_64.AppImage
+
+jobs:
+  build_appimage8:
+    name: Build AppImage EL8
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write # action-gh-release
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 149 # enough to cover between tags
+          #fetch-tags: true # this should work see actions/checkout~issue#1471
+
+      - name: Get the version
+        id: get_version
+        run: |
+          git show -s
+          version=$(cat VERSION) # 8.9.999
+          version_tstamp=$(git show -s "--format=%cs" | tr -d '-') # YYYYMMDD
+          version_hash=$(git show -s "--format=%h") # abcdefg
+          version_num=$(ruby -e "print '$GITHUB_REF'.split('/')[2]") # legacy version method: master
+          echo "version=${version}"
+          echo "version_tstamp=${version_tstamp}"
+          echo "version_hash=${version_hash}"
+          echo "version_num=${version_num}"
+          VERSION_NUM="${version}~${version_tstamp}~${version_hash}"
+          echo "VERSION_NUM=${VERSION_NUM}" >> $GITHUB_ENV
+          echo "MAGIC_APPIMAGE_OUTPUT_FILENAME=Magic-${VERSION_NUM}-x86_64-EL8.AppImage" >> $GITHUB_ENV
+          # Is this GHA being run due to a push-on-tag ?  if so we make a GitHub release, otherwise we just publish artifact
+          github_tag=$(echo -n "$GITHUB_REF" | sed -e 's#refs/tags/##') # 8.9.999
+          echo "github_tag=$github_tag"
+          if echo -n "$GITHUB_REF" | egrep -q "^refs/tags/" # check prefix
+          then
+            if [ -n "$github_tag" ]
+            then
+              echo "MY_GITHUB_TAG=${github_tag}" >> $GITHUB_ENV
+            fi
+          fi
+
+      - name: Build project
+        run: |
+          cd appimage/8
+          make
+
+          ln -v Magic-x86_64.AppImage "${MAGIC_APPIMAGE_OUTPUT_FILENAME}"
+          ls -l *.AppImage
+          sha256sum *.AppImage
+          pwd
+
+      - name: Create RELEASE-NOTES.txt
+        run: |
+          cd appimage/8
+          # Find the last tag (that does not match the current GITHUB_REF)
+          echo GITHUB_REF=$GITHUB_REF
+          echo GITHUB_SHA=$GITHUB_SHA
+          # GitHub CI is a shallow checkout by default (just the files needed to build)
+          # but we also want history back to next tag, see fetch-tags/fetch-depth actions/checkout~issue#1471
+          if [[ "$GITHUB_REF" =~ ^refs/tags/ ]]
+          then
+            # remove only if ref of tag (to avoid conflict during fetch)
+            git update-ref -d $GITHUB_REF
+            echo git_update_ref_exitstatus=$?
+          fi
+          set +e
+          git fetch --tags --prune --no-recurse-submodules --depth=149 origin +$GITHUB_SHA # fetch-tags: true # is broken
+          echo git_fetch_exitstatus=$?
+          git_show_ref=$(git show-ref --hash $GITHUB_REF) # get tagcommit hash
+          git_show_ref_exitstatus=$?
+          echo git_show_ref_exitstatus=$git_show_ref_exitstatus
+          echo git_show_ref=$git_show_ref
+          git_rev_list=$(git rev-list -n1 $GITHUB_REF) # get commit hash
+          git_rev_list_exitstatus=$?
+          echo git_rev_list_exitstatus=$git_rev_list_exitstatus
+          echo git_rev_list=$git_rev_list
+          set -e
+          test "$git_show_ref" = "$GITHUB_SHA" || test "$git_rev_list" = "$GITHUB_SHA" # check we got the ref back (or fail CI)
+          git_describe=$(git describe --tags $GITHUB_SHA | sed -e 's#\-\([0-9]\+\-g\)#\+\1#') # /-\d+-g/
+          echo git_describe=$git_describe
+
+          # RELEASE-NOTES-EL8.txt
+          echo "### ${MAGIC_APPIMAGE_OUTPUT_FILENAME} commit ${git_describe}" | sed -e 's#~#\\~#g' > RELEASE-NOTES-EL8.txt
+          echo "" >> RELEASE-NOTES-EL8.txt
+          echo "This release is based on EL8 (AlmaLinux8), the AppImage format is designed to run on a wide range of Linux distributions." >> RELEASE-NOTES-EL8.txt
+          echo "" >> RELEASE-NOTES-EL8.txt
+          echo "See documentation at https://github.com/${GITHUB_REPOSITORY}/blob/${GITHUB_SHA:0:8}/appimage/8/README.md" >> RELEASE-NOTES-EL8.txt
+          echo "" >> RELEASE-NOTES-EL8.txt
+          length_info=$(stat "--format=%s bytes" "${MAGIC_APPIMAGE_OUTPUT_FILENAME}")
+          sha256_info=$(sha256sum "${MAGIC_APPIMAGE_OUTPUT_FILENAME}" | cut -d ' ' -f1)
+          echo "|   |   |" >> RELEASE-NOTES-EL8.txt
+          echo "| :-------- | :------ |" >> RELEASE-NOTES-EL8.txt
+          echo "| File Name | ${MAGIC_APPIMAGE_OUTPUT_FILENAME} |" | sed -e 's#~#\\~#g' >> RELEASE-NOTES-EL8.txt
+          echo "| File Length | ${length_info} |" >> RELEASE-NOTES-EL8.txt
+          echo "| File SHA256 | ${sha256_info} |" >> RELEASE-NOTES-EL8.txt
+          echo "" >> RELEASE-NOTES-EL8.txt
+
+          # RELEASE-NOTES-CL.txt
+          set +e # allow this to fail to empty string
+          git_previous_tag=$(git describe --tags --abbrev=0 $(git rev-list --tags --skip=1 --max-count=1))
+          echo git_previous_tag=$git_previous_tag
+          set -e
+          if [ -n "${git_previous_tag}" ]
+          then
+              echo "### Change Log (since previous tag):" > RELEASE-NOTES-CL.txt
+              echo "\`\`\`" >> RELEASE-NOTES-CL.txt
+              git log --oneline --no-color --no-decorate "refs/tags/${git_previous_tag}..${GITHUB_REF}" >> RELEASE-NOTES-CL.txt
+              echo "\`\`\`" >> RELEASE-NOTES-CL.txt
+          else
+              echo "### Change Log (last commit only):" > RELEASE-NOTES-CL.txt
+              echo "\`\`\`" >> RELEASE-NOTES-CL.txt
+              git log --oneline -n1 --no-color --no-decorate "${GITHUB_REF}" >> RELEASE-NOTES-CL.txt
+              echo "\`\`\`" >> RELEASE-NOTES-CL.txt
+          fi
+          echo "" >> RELEASE-NOTES-CL.txt
+
+          #echo "### Build Info:" > RELEASE-NOTES-BI.txt
+          # FIXME extract package version info and DSO symvers into RELEASE-NOTES.txt
+          #echo "" >> RELEASE-NOTES-BI.txt
+
+          cat RELEASE-NOTES-CL.txt >> RELEASE-NOTES-EL8.txt
+          cat RELEASE-NOTES-EL8.txt
+
+          # RELEASE-NOTES-DOCS.txt
+          echo "See documentation at https://github.com/${GITHUB_REPOSITORY}/blob/${GITHUB_SHA:0:8}/appimage/7/README.md" >> RELEASE-NOTES-DOCS.txt
+          echo "See documentation at https://github.com/${GITHUB_REPOSITORY}/blob/${GITHUB_SHA:0:8}/appimage/8/README.md" >> RELEASE-NOTES-DOCS.txt
+          echo "See documentation at https://github.com/${GITHUB_REPOSITORY}/blob/${GITHUB_SHA:0:8}/appimage/9/README.md" >> RELEASE-NOTES-DOCS.txt
+          echo "See documentation at https://github.com/${GITHUB_REPOSITORY}/blob/${GITHUB_SHA:0:8}/appimage/10/README.md" >> RELEASE-NOTES-DOCS.txt
+
+          # RELEASE-NOTES-GH.txt (this is shared for all AppImage for one tag)
+          echo "### commit ${git_describe}" | sed -e 's#~#\\~#g' > RELEASE-NOTES-GH.txt
+          if [[ "$GITHUB_REF" =~ ^refs/tags/ ]]
+          then
+            # show tag annotation with tags like before
+            git tag  --cleanup=strip "--format=%(contents)" -n "${GITHUB_REF:10}" | sed -e 's#\([~|]\)#\\\1#g' >> RELEASE-NOTES-GH.txt
+          fi
+          echo "" >> RELEASE-NOTES-GH.txt
+          cat RELEASE-NOTES-DOCS.txt >> RELEASE-NOTES-GH.txt
+          cat RELEASE-NOTES-CL.txt >> RELEASE-NOTES-GH.txt
+
+          # Show in action/artifact output
+          echo "## RELEASE NOTES" >> $GITHUB_STEP_SUMMARY
+          echo "" >> $GITHUB_STEP_SUMMARY
+          cat RELEASE-NOTES-EL8.txt >> $GITHUB_STEP_SUMMARY
+
+      - name: Upload Release Asset
+        if: ${{ env.MY_GITHUB_TAG != '' }} # if: ${{ github.ref_type == 'tag' }}
+        uses: softprops/action-gh-release@v2
+        with:
+          body_path: ${{ github.workspace }}/appimage/8/RELEASE-NOTES-GH.txt
+          files: |
+            ${{ github.workspace }}/appimage/8/${{env.MAGIC_APPIMAGE_OUTPUT_FILENAME}}
+            ${{ github.workspace }}/appimage/8/RELEASE-NOTES-EL8.txt
+
+      - name: Upload Artifact
+        #if: ${{ env.MY_GITHUB_TAG == '' }} # commented out to always upload
+        uses: actions/upload-artifact@v4
+        with:
+          name: ${{env.MAGIC_APPIMAGE_OUTPUT_FILENAME}}
+          path: |
+            ${{ github.workspace }}/appimage/8/${{env.MAGIC_APPIMAGE_OUTPUT_FILENAME}}

.github/workflows/appimage9.yml

@@ -0,0 +1,170 @@
+on:
+  push:
+    tags:
+      - "*"
+  workflow_dispatch:
+
+name: CI-appimage9
+
+env:
+  APPIMAGETOOL_DOWNLOAD_URL: https://github.com/AppImage/appimagetool/releases/download/continuous/appimagetool-x86_64.AppImage
+
+jobs:
+  build_appimage9:
+    name: Build AppImage EL9
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write # action-gh-release
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 149 # enough to cover between tags
+          #fetch-tags: true # this should work see actions/checkout~issue#1471
+
+      - name: Get the version
+        id: get_version
+        run: |
+          git show -s
+          version=$(cat VERSION) # 8.9.999
+          version_tstamp=$(git show -s "--format=%cs" | tr -d '-') # YYYYMMDD
+          version_hash=$(git show -s "--format=%h") # abcdefg
+          version_num=$(ruby -e "print '$GITHUB_REF'.split('/')[2]") # legacy version method: master
+          echo "version=${version}"
+          echo "version_tstamp=${version_tstamp}"
+          echo "version_hash=${version_hash}"
+          echo "version_num=${version_num}"
+          VERSION_NUM="${version}~${version_tstamp}~${version_hash}"
+          echo "VERSION_NUM=${VERSION_NUM}" >> $GITHUB_ENV
+          echo "MAGIC_APPIMAGE_OUTPUT_FILENAME=Magic-${VERSION_NUM}-x86_64-EL9.AppImage" >> $GITHUB_ENV
+          # Is this GHA being run due to a push-on-tag ?  if so we make a GitHub release, otherwise we just publish artifact
+          github_tag=$(echo -n "$GITHUB_REF" | sed -e 's#refs/tags/##') # 8.9.999
+          echo "github_tag=$github_tag"
+          if echo -n "$GITHUB_REF" | egrep -q "^refs/tags/" # check prefix
+          then
+            if [ -n "$github_tag" ]
+            then
+              echo "MY_GITHUB_TAG=${github_tag}" >> $GITHUB_ENV
+            fi
+          fi
+
+      - name: Build project
+        run: |
+          cd appimage/9
+          make
+
+          ln -v Magic-x86_64.AppImage "${MAGIC_APPIMAGE_OUTPUT_FILENAME}"
+          ls -l *.AppImage
+          sha256sum *.AppImage
+          pwd
+
+      - name: Create RELEASE-NOTES.txt
+        run: |
+          cd appimage/9
+          # Find the last tag (that does not match the current GITHUB_REF)
+          echo GITHUB_REF=$GITHUB_REF
+          echo GITHUB_SHA=$GITHUB_SHA
+          # GitHub CI is a shallow checkout by default (just the files needed to build)
+          # but we also want history back to next tag, see fetch-tags/fetch-depth actions/checkout~issue#1471
+          if [[ "$GITHUB_REF" =~ ^refs/tags/ ]]
+          then
+            # remove only if ref of tag (to avoid conflict during fetch)
+            git update-ref -d $GITHUB_REF
+            echo git_update_ref_exitstatus=$?
+          fi
+          set +e
+          git fetch --tags --prune --no-recurse-submodules --depth=149 origin +$GITHUB_SHA # fetch-tags: true # is broken
+          echo git_fetch_exitstatus=$?
+          git_show_ref=$(git show-ref --hash $GITHUB_REF) # get tagcommit hash
+          git_show_ref_exitstatus=$?
+          echo git_show_ref_exitstatus=$git_show_ref_exitstatus
+          echo git_show_ref=$git_show_ref
+          git_rev_list=$(git rev-list -n1 $GITHUB_REF) # get commit hash
+          git_rev_list_exitstatus=$?
+          echo git_rev_list_exitstatus=$git_rev_list_exitstatus
+          echo git_rev_list=$git_rev_list
+          set -e
+          test "$git_show_ref" = "$GITHUB_SHA" || test "$git_rev_list" = "$GITHUB_SHA" # check we got the ref back (or fail CI)
+          git_describe=$(git describe --tags $GITHUB_SHA | sed -e 's#\-\([0-9]\+\-g\)#\+\1#') # /-\d+-g/
+          echo git_describe=$git_describe
+
+          # RELEASE-NOTES-EL9.txt
+          echo "### ${MAGIC_APPIMAGE_OUTPUT_FILENAME} commit ${git_describe}" | sed -e 's#~#\\~#g' > RELEASE-NOTES-EL9.txt
+          echo "" >> RELEASE-NOTES-EL9.txt
+          echo "This release is based on EL9 (AlmaLinux9), the AppImage format is designed to run on a wide range of Linux distributions." >> RELEASE-NOTES-EL9.txt
+          echo "" >> RELEASE-NOTES-EL9.txt
+          echo "See documentation at https://github.com/${GITHUB_REPOSITORY}/blob/${GITHUB_SHA:0:8}/appimage/9/README.md" >> RELEASE-NOTES-EL9.txt
+          echo "" >> RELEASE-NOTES-EL9.txt
+          length_info=$(stat "--format=%s bytes" "${MAGIC_APPIMAGE_OUTPUT_FILENAME}")
+          sha256_info=$(sha256sum "${MAGIC_APPIMAGE_OUTPUT_FILENAME}" | cut -d ' ' -f1)
+          echo "|   |   |" >> RELEASE-NOTES-EL9.txt
+          echo "| :-------- | :------ |" >> RELEASE-NOTES-EL9.txt
+          echo "| File Name | ${MAGIC_APPIMAGE_OUTPUT_FILENAME} |" | sed -e 's#~#\\~#g' >> RELEASE-NOTES-EL9.txt
+          echo "| File Length | ${length_info} |" >> RELEASE-NOTES-EL9.txt
+          echo "| File SHA256 | ${sha256_info} |" >> RELEASE-NOTES-EL9.txt
+          echo "" >> RELEASE-NOTES-EL9.txt
+
+          # RELEASE-NOTES-CL.txt
+          set +e # allow this to fail to empty string
+          git_previous_tag=$(git describe --tags --abbrev=0 $(git rev-list --tags --skip=1 --max-count=1))
+          echo git_previous_tag=$git_previous_tag
+          set -e
+          if [ -n "${git_previous_tag}" ]
+          then
+              echo "### Change Log (since previous tag):" > RELEASE-NOTES-CL.txt
+              echo "\`\`\`" >> RELEASE-NOTES-CL.txt
+              git log --oneline --no-color --no-decorate "refs/tags/${git_previous_tag}..${GITHUB_REF}" >> RELEASE-NOTES-CL.txt
+              echo "\`\`\`" >> RELEASE-NOTES-CL.txt
+          else
+              echo "### Change Log (last commit only):" > RELEASE-NOTES-CL.txt
+              echo "\`\`\`" >> RELEASE-NOTES-CL.txt
+              git log --oneline -n1 --no-color --no-decorate "${GITHUB_REF}" >> RELEASE-NOTES-CL.txt
+              echo "\`\`\`" >> RELEASE-NOTES-CL.txt
+          fi
+          echo "" >> RELEASE-NOTES-CL.txt
+
+          #echo "### Build Info:" > RELEASE-NOTES-BI.txt
+          # FIXME extract package version info and DSO symvers into RELEASE-NOTES.txt
+          #echo "" >> RELEASE-NOTES-BI.txt
+
+          cat RELEASE-NOTES-CL.txt >> RELEASE-NOTES-EL9.txt
+          cat RELEASE-NOTES-EL9.txt
+
+          # RELEASE-NOTES-DOCS.txt
+          echo "See documentation at https://github.com/${GITHUB_REPOSITORY}/blob/${GITHUB_SHA:0:8}/appimage/7/README.md" >> RELEASE-NOTES-DOCS.txt
+          echo "See documentation at https://github.com/${GITHUB_REPOSITORY}/blob/${GITHUB_SHA:0:8}/appimage/8/README.md" >> RELEASE-NOTES-DOCS.txt
+          echo "See documentation at https://github.com/${GITHUB_REPOSITORY}/blob/${GITHUB_SHA:0:8}/appimage/9/README.md" >> RELEASE-NOTES-DOCS.txt
+          echo "See documentation at https://github.com/${GITHUB_REPOSITORY}/blob/${GITHUB_SHA:0:8}/appimage/10/README.md" >> RELEASE-NOTES-DOCS.txt
+
+          # RELEASE-NOTES-GH.txt (this is shared for all AppImage for one tag)
+          echo "### commit ${git_describe}" | sed -e 's#~#\\~#g' > RELEASE-NOTES-GH.txt
+          if [[ "$GITHUB_REF" =~ ^refs/tags/ ]]
+          then
+            # show tag annotation with tags like before
+            git tag  --cleanup=strip "--format=%(contents)" -n "${GITHUB_REF:10}" | sed -e 's#\([~|]\)#\\\1#g' >> RELEASE-NOTES-GH.txt
+          fi
+          echo "" >> RELEASE-NOTES-GH.txt
+          cat RELEASE-NOTES-DOCS.txt >> RELEASE-NOTES-GH.txt
+          cat RELEASE-NOTES-CL.txt >> RELEASE-NOTES-GH.txt
+
+          # Show in action/artifact output
+          echo "## RELEASE NOTES" >> $GITHUB_STEP_SUMMARY
+          echo "" >> $GITHUB_STEP_SUMMARY
+          cat RELEASE-NOTES-EL9.txt >> $GITHUB_STEP_SUMMARY
+
+      - name: Upload Release Asset
+        if: ${{ env.MY_GITHUB_TAG != '' }} # if: ${{ github.ref_type == 'tag' }}
+        uses: softprops/action-gh-release@v2
+        with:
+          body_path: ${{ github.workspace }}/appimage/9/RELEASE-NOTES-GH.txt
+          files: |
+            ${{ github.workspace }}/appimage/9/${{env.MAGIC_APPIMAGE_OUTPUT_FILENAME}}
+            ${{ github.workspace }}/appimage/9/RELEASE-NOTES-EL9.txt
+
+      - name: Upload Artifact
+        #if: ${{ env.MY_GITHUB_TAG == '' }} # commented out to always upload
+        uses: actions/upload-artifact@v4
+        with:
+          name: ${{env.MAGIC_APPIMAGE_OUTPUT_FILENAME}}
+          path: |
+            ${{ github.workspace }}/appimage/9/${{env.MAGIC_APPIMAGE_OUTPUT_FILENAME}}

.github/workflows/canary-matrix.yml

@@ -12,37 +12,35 @@ jobs:
     strategy:
       max-parallel: 3
       matrix:
-        os: [ubuntu-24.04, ubuntu-22.04, ubuntu-20.04]
+        os: [ubuntu-24.04, ubuntu-22.04]
         # Configure Options
-        pkgs: [all, none, no_tk_tcl_rl, no_rl, no_zlib, no_gc_gl_gu, no_gc_gu]
+        #                                                       X11          OGL    CAIRO
+        pkgs: [all, none, no_tk_tcl_rl, no_tk_tcl_brl, no_zlib, no_gc_gl_gu, no_gc, no_gl_gu]
         # Toolchain
-        #  ubuntu-20.04 [gcc-9] gcc-10
-        #  ubuntu-22.04 [gcc-11] gcc-12
-        #  ubuntu-24.04 [gcc-13] gcc-14
-        tc:  [default, gcc-10, gcc-12, gcc-14, clang-17, clang-18]
+        #  ubuntu-20.04 [gcc-9,  clang-10]
+        #  ubuntu-22.04 [gcc-11, clang-14]
+        #  ubuntu-24.04 [gcc-13, clang-18]
+        tc:  [default, gcc-10, gcc-11, gcc-12, gcc-13, gcc-14, clang-14, clang-15, clang-17, clang-18, clang-19]
         exclude:
-          - os: ubuntu-20.04
-            tc: gcc-12
-          - os: ubuntu-20.04
-            tc: gcc-14
-          - os: ubuntu-20.04
-            tc: clang-17
-          - os: ubuntu-20.04
-            tc: clang-18
-
           - os: ubuntu-22.04
-            tc: gcc-10
+            tc: gcc-13
           - os: ubuntu-22.04
             tc: gcc-14
           - os: ubuntu-22.04
             tc: clang-17
-          - os: ubuntu-22.04
+          - os: ubuntu-22.04 # some sources show this as present but not found
             tc: clang-18
+          - os: ubuntu-22.04
+            tc: clang-19
 
           - os: ubuntu-24.04
             tc: gcc-10
           - os: ubuntu-24.04
-            tc: gcc-12
+            tc: gcc-11
+          - os: ubuntu-24.04
+            tc: clang-14
+          - os: ubuntu-24.04
+            tc: clang-15
       fail-fast: false
     runs-on: ${{ matrix.os }}
     steps:
@@ -69,16 +67,19 @@ jobs:
           # z no.*_zl  zlib1g-dev
           # n no.*_nc  libncurses-dev
           # r no.*_rl  libreadline-dev
+          # R no.*_brl --enable-readline-bundled
           # c no.*_tcl tcl-dev
           # k no.*_tk  tk-dev
           # C no.*_gc  libcairo-dev
           # L no.*_gl  libgl-dev
-          # U no.*_gu  libglu1-mesa-dev
+          # U no.*_gu  libglu1-mesa-dev  # GLU requires GL
           # X no.*_gx  libx11-dev
           if echo -n "$MATRIX_PKGS" | grep -q "^no.*_zl"; then
             pkgs=$(echo -n "$pkgs" | sed -e 's#z##'); fi
           if echo -n "$MATRIX_PKGS" | grep -q "^no.*_nc"; then
             pkgs=$(echo -n "$pkgs" | sed -e 's#n##'); fi
+          if echo -n "$MATRIX_PKGS" | grep -q "^no.*_brl"; then
+            pkgs=$(echo -n "$pkgs" | sed -e 's#r#R#'); fi # replace
           if echo -n "$MATRIX_PKGS" | grep -q "^no.*_rl"; then
             pkgs=$(echo -n "$pkgs" | sed -e 's#r##'); fi
           if echo -n "$MATRIX_PKGS" | grep -q "^no.*_tcl"; then
@@ -111,6 +112,8 @@ jobs:
           _configure_args=()
           if echo -n "$MATRIX_PKGS" | grep -q "^no.*_zl"; then
             _configure_args+=(--disable-compression); fi
+          if echo -n "$MATRIX_PKGS" | grep -q "^no.*_brl"; then
+            _configure_args+=(--enable-readline-bundled); fi
           if echo -n "$MATRIX_PKGS" | grep -q "^no.*_rl"; then
             _configure_args+=(--disable-readline); fi
           if echo -n "$MATRIX_PKGS" | grep -q "^no.*_tcl"; then
@@ -135,6 +138,8 @@ jobs:
           echo "BUILD_GCC_VERSION=$BUILD_GCC_VERSION" >> $GITHUB_ENV
           echo "BUILD_CLANG_VERSION=$BUILD_CLANG_VERSION" >> $GITHUB_ENV
 
+          sudo apt-get update
+
           if [ -n "$BUILD_GCC_VERSION" ]
           then
             GCCV=$BUILD_GCC_VERSION
@@ -203,6 +208,7 @@ jobs:
             export CPP="clang-cpp-${BUILD_CLANG_VERSION}"
           fi
 
+          set -o pipefail # due to pipe inside CI
           ./configure $CONFIGURE_ARGS 2>&1 | tee CONFIGURE.LOG
 
           egrep "^(CPP|CXX|CC)\s" defs.mak

.github/workflows/main-aarch64.yml

@@ -0,0 +1,23 @@
+# CI for native ARM64 Linux build.
+
+name: CI-aarch64
+
+on:
+  push:
+  pull_request:
+  workflow_dispatch:
+
+jobs:
+  simple_build_linux_arm:
+    runs-on: ubuntu-24.04-arm
+    steps:
+      - uses: actions/checkout@v4
+      - name: Get Dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y tcl-dev tk-dev libcairo-dev
+      - name: Build
+        run: |
+          ./configure
+          make database/database.h
+          make -j$(nproc)

.github/workflows/main-macos.yml

@@ -10,8 +10,8 @@ on:
 
 # A workflow run is made up of one or more jobs that can run sequentially or in parallel
 jobs:
-  simple_build_macos13:
-    runs-on: macos-13
+  simple_build_macos15:
+    runs-on: macos-15-intel # only and last supported intel MacOS
     timeout-minutes: 45 # x86_64 seems non-SSD based (slower)
     steps:
       - name: Checkout
@@ -22,8 +22,8 @@ jobs:
         run: |
           brew install --cask xquartz
           PACKAGE_LIST="xquartz"
-          brew install cairo tcl-tk@8 tcsh
-          _package_list="cairo tcl-tk@8 tcsh"
+          brew install cairo tcl-tk@8 tcsh gnu-sed
+          _package_list="cairo tcl-tk@8 tcsh gnu-sed"
           # These seem needed maybe they are being provided from somewhere else GHA runner
           #  or brew transitive depend either way doesn't hurt to confirm they are installed.
           _package_list="$_package_list libglu freeglut"
@@ -54,6 +54,7 @@ jobs:
             brew info tcl-tk   > $TMPFILE && head -n1 $TMPFILE
             brew info tcl-tk@8 > $TMPFILE && head -n1 $TMPFILE
             brew info tcsh     > $TMPFILE && head -n1 $TMPFILE
+            brew info gnu-sed  > $TMPFILE && head -n1 $TMPFILE
             echo ""
             cc -v 2>&1
             echo ""
@@ -234,10 +235,10 @@ jobs:
           cp *.mak dist/BUILD-INFO/
           cp *.LOG dist/BUILD-INFO/
 
-      - name: Upload archive magic-macos13
+      - name: Upload archive magic-macos15
         uses: actions/upload-artifact@v4
         with:
-          name: magic-macos13
+          name: magic-macos15
           path: |
             ${{ github.workspace }}/dist
 
@@ -253,8 +254,8 @@ jobs:
         run: |
           brew install --cask xquartz
           PACKAGE_LIST="xquartz"
-          brew install cairo tcl-tk@8 tcsh
-          _package_list="cairo tcl-tk@8 tcsh"
+          brew install cairo tcl-tk@8 tcsh gnu-sed
+          _package_list="cairo tcl-tk@8 tcsh gnu-sed"
           # These seem needed maybe they are being provided from somewhere else GHA runner
           #  or brew transitive depend either way doesn't hurt to confirm they are installed.
           _package_list="$_package_list libglu freeglut"
@@ -285,6 +286,7 @@ jobs:
             brew info tcl-tk   > $TMPFILE && head -n1 $TMPFILE
             brew info tcl-tk@8 > $TMPFILE && head -n1 $TMPFILE
             brew info tcsh     > $TMPFILE && head -n1 $TMPFILE
+            brew info gnu-sed  > $TMPFILE && head -n1 $TMPFILE
             echo ""
             cc -v 2>&1
             echo ""

.github/workflows/main-wasm.yml

@@ -0,0 +1,160 @@
+name: CI-wasm
+
+# Builds the Magic WebAssembly target on every push and pull request.
+# When the VERSION file changes on the default branch, the package is
+# additionally published to GitHub Packages (npm.pkg.github.com) as
+# @<owner>/magic-vlsi-wasm — no manual tag or token required.
+# Tim Edwards updates VERSION to trigger a new release; the scope resolves
+# automatically to the repo owner, so forks publish under their own namespace.
+#
+# WASM is architecture-independent — built once on x86-64, usable everywhere.
+
+on:
+  push:
+  pull_request:
+  workflow_dispatch:
+    inputs:
+      emsdk_version:
+        description: 'emsdk version to build with (default: latest; pin a version number to bisect)'
+        type: string
+        default: 'latest'
+      dry_run:
+        description: 'Dry run: pack only, do not publish even on tag pushes'
+        type: boolean
+        default: true
+
+# actions/upload-artifact@v5 still runs on Node.js 20. Force Node 24 to
+# silence the deprecation warning until upload-artifact ships a Node-24
+# release. Drop this once upgraded.
+env:
+  FORCE_JAVASCRIPT_ACTIONS_TO_NODE24: true
+
+permissions:
+  contents: read
+  packages: write
+
+jobs:
+  build-wasm:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v5
+        with:
+          fetch-depth: 2
+
+      - name: Set up Node.js
+        uses: actions/setup-node@v5
+        with:
+          node-version: '22'
+          registry-url: 'https://npm.pkg.github.com'
+
+      - name: Install emsdk
+        env:
+          # Defaults to latest so CI tracks emsdk HEAD and catches breakage early.
+          # Override via workflow_dispatch to pin a specific version when needed
+          # (e.g. to bisect a regression or verify a post-build.sh patch still applies).
+          EMSDK_VERSION: ${{ github.event.inputs.emsdk_version || 'latest' }}
+        run: |
+          git clone https://github.com/emscripten-core/emsdk.git
+          cd emsdk
+          ./emsdk install "$EMSDK_VERSION"
+          ./emsdk activate "$EMSDK_VERSION"
+
+      # Dump native + emscripten preprocessor defines. Useful for diagnosing
+      # WASM-build differences after an emsdk bump.
+      - name: Emscripten Diagnostic
+        run: |
+          source ./emsdk/emsdk_env.sh
+          echo "===== gcc -dM -E - =====";  echo | gcc  -dM -E - | sort
+          echo "===== g++ -dM -E - =====";  echo | g++  -dM -E - | sort
+          echo "===== emcc -dM -E - ====="; echo | emcc -dM -E - | sort
+          echo "===== em++ -dM -E - ====="; echo | em++ -dM -E - | sort
+
+      - name: Build WASM
+        run: |
+          source ./emsdk/emsdk_env.sh
+          # --without/--disable flags: no WASM library available for these features
+          CFLAGS="--std=c17 -D_DEFAULT_SOURCE=1 -DEMSCRIPTEN=1" emconfigure ./configure \
+            --without-cairo --without-opengl --without-x --without-tk --without-tcl \
+            --disable-readline --disable-compression \
+            --host=asmjs-unknown-emscripten \
+            --target=asmjs-unknown-emscripten
+          # Append WASM linker flags and activate the WASM link target
+          cat toolchains/emscripten/defs.mak >> defs.mak
+          # Echo the merged defs.mak so CI logs show the exact build config
+          echo "===== defs.mak ====="; cat defs.mak; echo "===== defs.mak ====="
+          # Build in order: techs must exist before mains (--embed-file embeds them)
+          emmake make depend
+          emmake make -j$(nproc) modules libs
+          emmake make techs
+          emmake make mains
+
+      - name: Copy WASM artifacts into npm/
+        run: |
+          cp magic/magic.js  npm/
+          cp magic/magic.wasm npm/
+
+      - name: Run example tests
+        run: cd npm && npm run test
+
+      # Dump generated text outputs (.ext, .spice, .cif, …) into the CI log
+      # so a regression in extraction / netlisting / cifoutput is visible
+      # without having to download artifacts. The .gds output is binary —
+      # skip it and just record its size.
+      - name: Display example outputs
+        run: |
+          shopt -s nullglob
+          for f in npm/examples/output/*; do
+            name=$(basename "$f")
+            case "$f" in
+              *.gds) echo "===== $name (binary, $(wc -c < "$f") bytes — skipped) =====" ;;
+              *)     echo "===== $name ====="; cat "$f" ;;
+            esac
+          done
+
+      - name: Set package version and scope
+        run: |
+          base=$(cat VERSION)                              # e.g. 8.3.637
+          date=$(git show -s --format=%cs | tr -d '-')    # e.g. 20260414
+          hash=$(git show -s --format=%h)                 # e.g. d157eea
+          VERSION="${base}-${date}.${hash}"
+          # Scope the package to the repo owner so it lands in the right
+          # GitHub Packages namespace regardless of who hosts the repo.
+          # e.g. @rtimothyedwards/magic-vlsi-wasm on Tim's repo,
+          #      @intubun/magic-vlsi-wasm on a fork.
+          SCOPED_NAME="@${{ github.repository_owner }}/magic-vlsi-wasm"
+          cd npm
+          npm pkg set name="$SCOPED_NAME"
+          npm pkg set publishConfig.registry="https://npm.pkg.github.com"
+          npm version "$VERSION" --no-git-tag-version
+
+      - name: Pack
+        run: ./npm/pack.sh
+
+      - name: Upload tarball as artifact
+        uses: actions/upload-artifact@v5
+        with:
+          name: magic-vlsi-wasm-npm
+          path: npm/*.tgz
+
+      - name: Check if VERSION changed
+        id: version_changed
+        if: github.event_name == 'push'
+        run: |
+          if echo "${{ github.ref }}" | grep -q '^refs/tags/'; then
+            echo "changed=true" >> $GITHUB_OUTPUT
+          elif [ "${{ github.ref }}" = "refs/heads/${{ github.event.repository.default_branch }}" ]; then
+            if git diff --name-only HEAD~1 HEAD 2>/dev/null | grep -q '^VERSION$'; then
+              echo "changed=true" >> $GITHUB_OUTPUT
+            else
+              echo "changed=false" >> $GITHUB_OUTPUT
+            fi
+          else
+            echo "changed=false" >> $GITHUB_OUTPUT
+          fi
+
+      - name: Publish to GitHub Packages
+        if: steps.version_changed.outputs.changed == 'true' && github.event.inputs.dry_run != 'true'
+        run: cd npm && npm publish
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/main.yml

@@ -1,58 +1,21 @@
-# This is a basic workflow to help you get started with Actions
-
 name: CI
 
-# Controls when the workflow will run
 on:
   push:
   pull_request:
   workflow_dispatch:
 
-# A workflow run is made up of one or more jobs that can run sequentially or in parallel
 jobs:
-  vezzal:
-    # The type of runner that the job will run on
-    runs-on: ubuntu-latest
-    # Steps represent a sequence of tasks that will be executed as part of the job
-    steps:
-      - name: Pulling the docker image
-        run: docker pull vezzal/vezzal:v1
-
-      - name: Start the container with the docker image
-        run: docker run -id --name test_magic vezzal/vezzal:v1 bash | exit
-
-      - name: Run the testing on the container and send the mail
-        run: docker exec test_magic /vezzal/test_magic.sh "lankasaicharan123@gmail.com,tim@opencircuitdesign.com" ${{secrets.MAILING_KEY}}
   simple_build_linux:
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
       - name: Get Dependencies
         run: |
+          sudo apt-get update
           sudo apt-get install -y tcl-dev tk-dev libcairo-dev
       - name: Build
         run: |
           ./configure
           make database/database.h
           make -j$(nproc)
-  simple_build_wasm:
-    runs-on: ubuntu-20.04
-    steps:
-      - uses: actions/checkout@v4
-      - name: Get Dependencies
-        run: |
-          git clone https://github.com/emscripten-core/emsdk.git
-          cd emsdk
-          ./emsdk install latest
-          ./emsdk activate latest
-      - name: Build
-        run: |
-          source ./emsdk/emsdk_env.sh
-          emconfigure ./configure --without-cairo --without-opengl --without-x --disable-readline --disable-compression --target=asmjs-unknown-emscripten
-          emmake make
-      - name: archive wasm bundle
-        uses: actions/upload-artifact@v4
-        with:
-          name: magic-wasm-bundle
-          path: |
-            ${{ github.workspace }}/magic/magic.wasm

.gitignore

@@ -1,19 +1,33 @@
+# Autoconf / configure outputs
 defs.mak
-*/Depend
+!toolchains/emscripten/defs.mak
 config.cache
 config.log
 scripts/config.log
 scripts/config.status
 scripts/defs.mak
-.*.swp
-*.o
-*.so
-*~
-scmos/cif_template/objs/*
-database/database.h
 install.log
-magic/proto.magicrc
 make.log
+reconfigure.sh
+
+# Compiled objects / libraries
+*.o
+*.a
+*.so
+*/Depend
+database/database.h
+
+# Editor / OS cruft
+.*.swp
+.*.swo
+*~
+.DS_Store
+.vscode/
+.idea/
+
+# Magic runtime-generated files
+magic/proto.magicrc
+scmos/cif_template/objs/*
 scmos/gdsquery.tech
 scmos/minimum.tech
 scmos/scmos-sub.tech
@@ -21,14 +35,28 @@ scmos/scmos-tm.tech
 scmos/scmos.tech
 scmos/scmosWR.tech
 scmos/nmos.tech
+
+# Native build artifacts
+magic/magic
+magic/tclmagic.dylib
 tcltk/magic.sh
 tcltk/magic.tcl
 tcltk/magicdnull
 tcltk/magicexec
 tcltk/ext2spice.sh
 tcltk/ext2sim.sh
-magic/tclmagic.dylib
 tcltk/magicdnull.dSYM/
 tcltk/magicexec.dSYM/
-reconfigure.sh
 pfx/
+
+# WASM build artifacts
+magic/magic.js
+magic/magic.js.symbols
+magic/magic.symbols
+magic/magic.wasm
+net2ir/net2ir
+net2ir/net2ir.js
+net2ir/net2ir.wasm
+
+# Generated test output
+npm/examples/output/

INSTALL_MacOS.md

@@ -3,11 +3,10 @@
 Get [Homebrew](https://brew.sh).
 
 ```sh
-# TCL9 should be supported soon (Q2 2025)
-brew install cairo tcl-tk@8 python3
+brew install cairo tcl-tk@8 python3 gnu-sed
 brew install --cask xquartz
 ./scripts/configure_mac
-# If you have both TCL8 and TCL9 installed you may need to verify TCL8 was selected.
+# If you have both TCL8 and TCL9 installed you may need to verify which was selected.
 make database/database.h
 make -j$(sysctl -n hw.ncpu)
 make install # may need sudo depending on your setup

Makefile

@@ -4,31 +4,33 @@
 
 MAGICDIR   = .
 PROGRAMS   = magic
-TECH       = scmos
+TECHS      = scmos
 LIBRARIES  = database utils extflat
 MODULES    = bplane cmwind commands database dbwind debug drc extflat \
 	     extract graphics netmenu plow resis select sim textio tiles \
 	     utils windows wiring
 
+# This was `cat VERSION`
+VERSION    := $(shell cat ${MAGICDIR}/VERSION)
+
 MAKEFLAGS  =
-INSTALL_CAD_DIRS = windows doc ${TECH}
+INSTALL_CAD_DIRS = windows doc ${TECHS}
 
 -include defs.mak
 
-all:	$(ALL_TARGET)
+all:	$(ALL_TARGET) techs
 
-standard:
-	@echo --- errors and warnings logged in file make.log
-	@${MAKE} mains
+standard: mains
 
-tcl:
-	@echo --- errors and warnings logged in file make.log
-	@${MAKE} tcllibrary
+tcl: tcllibrary
 
-force: clean all
+force:
+	@${MAKE} clean
+	@${MAKE} all
 
 defs.mak:
 	@echo No \"defs.mak\" file found.  Run "configure" to make one.
+	@exit 1
 
 config:
 	${MAGICDIR}/configure
@@ -43,24 +45,56 @@ mains: database/database.h modules libs
 	for dir in ${PROGRAMS}; do \
 		(cd $$dir && ${MAKE} main) || exit 1; done
 
-database/database.h: database/database.h.in
+database/database.h: ${MAGICDIR}/database/database.h.in
 	@echo --- making header file database/database.h
-	${SCRIPTS}/makedbh database/database.h.in database/database.h
+	${SCRIPTS}/makedbh ${MAGICDIR}/database/database.h.in database/database.h
 
-modules: database/database.h depend
-	@echo --- making modules
-	for dir in ${MODULES} ${PROGRAMS}; do \
-		(cd $$dir && ${MAKE} module) || exit 1; done
+# tiles xyz => tiles/libtiles.o xyz/libxyz.o
+MODULES_SUBDIR := $(shell for i in ${MODULES}; do echo "$${i}/lib$${i}.o"; done)
+# tiles xyz => tiles/libtiles.a xyz/libxyz.a
+LIBS_SUBDIR := $(shell for i in ${MODULES}; do echo "$${i}/lib$${i}.a"; done)
 
-libs:
-	@echo --- making libraries
-	for dir in ${LIBRARIES}; do \
-		(cd $$dir && ${MAKE} lib) || exit 1; done
+.PHONY: FORCE
+${MODULES_SUBDIR}: FORCE
+	@${MAKE} -C $(dir $@) module
 
-depend:	database/database.h
+.PHONY: modules
+modules: database/database.h depend ${MODULES_SUBDIR}
+
+${LIBS_SUBDIR}: FORCE
+	@${MAKE} -C $(dir $@) lib
+
+# Force the tiles/utils modules to exist first for libdatabase.a
+.PHONY: libs
+libs: database/database.h depend tiles/libtiles.o utils/libutils.o ${LIBS_SUBDIR}
+
+#
+# extcheck - utility tool
+# net2ir   - utility tool
+# oa       - disabled (needs 'clean' target renaming)
+SUBDIRS = bplane cmwind commands database dbwind debug drc extflat extract graphics \
+	  magic netmenu plow resis select sim textio tiles utils windows wiring
+
+BUNDLED_MODULES = readline lisp
+
+# Unique list of all subdir that might have Depend file, we have to deduplicate otherwise
+# MAKE will warning loudly.  This list is somewhat empty when defs.mak does not exist
+SUBDIRS_FILTERED := $(shell echo ${MODULES} ${PROGRAMS} ${SUBDIRS} | tr ' ' '\n' | sort | uniq)
+
+SUBDIRS_DEPEND = $(addsuffix /Depend, ${SUBDIRS_FILTERED})
+
+${SUBDIRS_DEPEND}: database/database.h
 	@echo --- making dependencies
-	for dir in ${MODULES} ${UNUSED_MODULES} ${PROGRAMS}; do \
-		(cd $$dir && ${MAKE} depend) || exit 1; done
+	${MAKE} -C $(dir $@) depend
+
+.PHONY: depend
+depend: defs.mak ${SUBDIRS_DEPEND}
+
+.PHONY: techs
+techs: depend
+	@echo --- making techs
+	for dir in ${TECHS}; do \
+		(cd $$dir && ${MAKE} all) || exit 1; done
 
 install: $(INSTALL_TARGET)
 
@@ -95,7 +129,7 @@ install-tcl-real: install-tcl-dirs
 		(cd $$dir && ${MAKE} install-tcl); done
 
 clean:
-	for dir in ${MODULES} ${PROGRAMS} ${TECH} ${UNUSED_MODULES}; do \
+	for dir in ${SUBDIRS_FILTERED} ${TECHS} ${BUNDLED_MODULES}; do \
 		(cd $$dir && ${MAKE} clean); done
 	${RM} *.tmp */*.tmp *.sav */*.sav *.log TAGS tags
 
@@ -105,18 +139,19 @@ distclean:
 	${RM} defs.mak old.defs.mak ${MAGICDIR}/scripts/defs.mak
 	${RM} ${MAGICDIR}/scripts/default.conf
 	${RM} ${MAGICDIR}/scripts/config.log ${MAGICDIR}/scripts/config.status
-	${RM} scripts/magic.spec magic-`cat VERSION` magic-`cat VERSION`.tgz
-	${RM} *.log */Depend
+	${RM} database/database.h
+	${RM} scripts/magic.spec magic-${VERSION} magic-${VERSION}.tgz
+	${RM} *.log
 
 dist:
-	${RM} scripts/magic.spec magic-`cat VERSION` magic-`cat VERSION`.tgz
-	sed -e /@VERSION@/s%@VERSION@%`cat VERSION`% \
+	${RM} scripts/magic.spec magic-${VERSION} magic-${VERSION}.tgz
+	${SED} -e /@VERSION@/s%@VERSION@%${VERSION}% \
 	    scripts/magic.spec.in > scripts/magic.spec
-	ln -nsf . magic-`cat VERSION`
-	tar zchvf magic-`cat VERSION`.tgz --exclude CVS \
-	    --exclude magic-`cat VERSION`/magic-`cat VERSION` \
-	    --exclude magic-`cat VERSION`/magic-`cat VERSION`.tgz \
-	    magic-`cat VERSION`
+	${LN} -nsf . magic-${VERSION}
+	tar zchvf magic-${VERSION}.tgz --exclude CVS \
+	    --exclude magic-${VERSION}/magic-${VERSION} \
+	    --exclude magic-${VERSION}/magic-${VERSION}.tgz \
+	    magic-${VERSION}
 
 clean-mains:
 	for dir in ${PROGRAMS}; do \
@@ -133,6 +168,6 @@ TAGS:
 setup-git:
 	git config --local include.path ../.gitconfig
 	git stash save
-	rm .git/index
+	${RM} .git/index
 	git checkout HEAD -- "$$(git rev-parse --show-toplevel)"
 	git stash pop

VERSION

@@ -1 +1 @@
-8.3.521
+8.3.661

appimage/10/Dockerfile

@@ -0,0 +1,59 @@
+FROM almalinux:10
+
+USER root
+
+# Build Dependencies (and dump version to logging)
+RUN dnf install -y python3 zlib-devel ncurses-devel readline-devel cairo-devel freeglut-devel \
+	mesa-libGLU-devel mesa-libGL-devel libX11-devel libstdc++-devel gcc gcc-c++ make git tcsh \
+	zip \
+    && echo "### rpm -qa:" \
+    && rpm -qa | sort \
+    && echo ""
+#RUN dnf group install -y "Development Tools"
+
+# Tcl/Tk
+WORKDIR /tcl
+RUN curl -L https://prdownloads.sourceforge.net/tcl/tcl9.0.1-src.tar.gz | tar --strip-components=1 -xzC . \
+    && cd unix \
+    && ./configure --prefix=/prefix \
+    && make \
+    && make install install-libraries install-msgs install-tzdata
+
+WORKDIR /tk
+RUN curl -L https://prdownloads.sourceforge.net/tcl/tk9.0.1-src.tar.gz | tar --strip-components=1 -xzC . \
+    && cd unix \
+    && ./configure --prefix=/prefix --with-tcl=/prefix/lib \
+    && make \
+    && make install install-libraries
+
+WORKDIR /prefix/bin
+RUN cp ./wish9.0 ./wish
+RUN cp ./tclsh9.0 ./tclsh
+
+# Magic
+WORKDIR /magic
+COPY . .
+
+RUN ./configure \
+    --prefix=/prefix \
+    --with-tcl=/prefix/lib \
+    --with-tk=/prefix/lib \
+    && make clean \
+    && make database/database.h \
+    && make -j$(nproc) \
+    && make install
+
+# Produce summary of what was created and confirm their DSOs
+RUN echo "### filesystem:" \
+    find /prefix -printf "%y/%M/%m %i/%n %l %u/%U %g/%G %s/%b %T+/%T@\t%p\n"; \
+    ls -lR /prefix; \
+    find /prefix -type f -perm /111 -exec bash -c "echo \#\#\# {}; ldd -v {}" \; 2>/dev/null; \
+    for name in libgcc_s libstdc++ libpng liblzma libxml2 libz libcairo libGL libGLU; do \
+      find /lib64 /usr/lib64 -maxdepth 2 -name "*.so" -name "${name}*" -exec bash -c "echo \#\#\# {}; ldd -v {}" \; 2>/dev/null; \
+    done; \
+    echo "###"
+
+WORKDIR /
+RUN tar -czf /prefix.tar.gz -C ./prefix .
+
+CMD ["/bin/bash"]

appimage/10/Makefile

@@ -0,0 +1,46 @@
+MAGIC_SRC_ROOT = ../..
+RESOURCES := $(shell find ../rsc/ -type f)
+ARCH := $(shell uname -m)
+APPIMAGE = Magic-$(ARCH).AppImage
+VERSION_MAGIC := $(shell cat $(MAGIC_SRC_ROOT)/VERSION)
+VERSION_TSTAMP := $(shell git show -s "--format=%cs" | tr -d '-')
+VERSION_HASH := $(shell git show -s "--format=%h")
+VERSION_NUM ?= $(VERSION_MAGIC)~$(VERSION_TSTAMP)~$(VERSION_HASH)
+VERSION := $(VERSION_NUM)
+
+# Allow CI to override
+APPIMAGETOOL_DOWNLOAD_URL ?= https://github.com/AppImage/appimagetool/releases/download/continuous/appimagetool-x86_64.AppImage
+
+all: $(APPIMAGE)
+
+.PHONY: prefix/bin/magic
+prefix/bin/magic: Dockerfile Makefile
+	@echo "APPIMAGE=$(APPIMAGE)"
+	@echo "VERSION=$(VERSION)"
+	@echo "ARCH=$(ARCH)"
+	@echo "RESOURCES=$(RESOURCES)"
+	rm -rf prefix
+	docker build -t magic_build -f ./Dockerfile $(MAGIC_SRC_ROOT)
+	id=$$(docker create magic_build) ; \
+	docker cp $$id:/prefix ./prefix ; \
+	docker rm -v $$id
+	mkdir -p prefix/lib/tcl9.0.1
+	cp -r prefix/lib/tcl9.0 prefix/lib/tcl9.0.1/library
+
+appimagetool:
+	curl -L "$(APPIMAGETOOL_DOWNLOAD_URL)" > ./appimagetool
+	chmod +x ./appimagetool
+
+$(APPIMAGE): prefix/bin/magic appimagetool $(RESOURCES)
+	cp $(RESOURCES) ./prefix/
+	./appimagetool prefix
+
+PREFIX ?= /usr/local
+install:
+	install $(APPIMAGE) $(PREFIX)/bin/magic
+
+.PHONY: clean
+clean:
+	rm -f *.AppImage
+	rm -f prefix.tar.gz
+	rm -rf prefix

appimage/10/README.md

@@ -0,0 +1,127 @@
+This is an AppImage that runs on all GNU/Linux platforms with:
+
+* FUSE
+    * This excludes non-privileged Docker containers unfortunately, unless pre-extracted.
+* GLIBC 2.38+
+* Cairo 1.18+
+* May require runtime CPU matching Linux ABI x86-64-v3 and newer (CPUs with SSE4.2/AVX2/BMI2/FMA via `lscpu`).
+
+This AppImage build is based on EL10 (via AlmaLinux 10).
+
+AlmaLinux 10 was first released on 27 May 2025.
+
+# Version Info
+
+See the AppImage main binary file naming, release tag information and AppInfo metadata
+for the exact magic version inside the archive.  When starting AppImage by default the
+Tcl console banner can also provide version information, also using the `version` Tcl
+command.
+
+# Build Info
+
+* Based on AlmaLinux 10 (EL10)
+* Tcl/Tk 9.0.1
+* and Magic 8.x
+* all default modules enabled (including all Display drivers cairo/X11/OpenGL)
+
+# FAQ: How to use
+
+Download the *.AppImage file relevant to your platform and run:
+
+```
+chmod +x Magic-x86_64.AppImage
+./Magic-x86_64.AppImage
+```
+
+Example startup with command line options:
+
+```
+./Magic-x86_64.AppImage -d XR -T scmos
+```
+
+# FAQ: How to use (inside docker / podman)
+
+```
+chmod +x Magic-x86_64.AppImage
+
+### Podman or Docker, use :Z when rootless with selinux enabled
+podman run --rm --device /dev/fuse --privileged \
+  -v "$(pwd):/tmp/work:Z" -v "/tmp/.X11-unix/X0:/tmp/.X11-unix/X0:Z" \
+  -e DISPLAY -ti almalinux:10
+
+### Inside Docker:
+dnf update -y
+
+dnf install -y fuse libX11 cairo libGL libGLU
+
+cd /tmp/work
+
+./Magic-x86_64.AppImage -d XR -T scmos
+```
+
+# Building Requirements
+
+* A reasonably recent GNU/Linux host
+* GNU make
+* Docker 20+
+* Git
+* curl
+
+The final build is then packaged into an AppImage using AppImageTool on the host machine.
+
+# Build Instructions
+`make`
+
+# Installation Instructions
+`make install`
+
+# FAQ: Is my CPU supported ?
+
+This is built with the standard x86_64 Linux ABI version for AlmaLinux 10.
+
+Use the command `/lib64/ld-linux-x86-64.so.2 --help` to see which CPUs your
+Linux distribtion supports (and your CPU) look for the word "supported".
+
+# FAQ: The DSO versioning link dependencies?
+
+The information here provides an outline of what versions to expect from EL10
+of the major dependencies, to assist you in a compatibility check with your
+Linux distribution of choice.
+
+The actual versions in our public releases can differ slightly inline with
+the EL10 support compatibility and ABI versioning policies for the support
+lifecycle of the distribution.
+
+The most important items are the Direct Dependencies and the availabilty
+of a suitable graphics DSO as per your '-d' choice.
+
+Direct Runtime Dependencies (from /prefix/**):
+
+| DSO Filename           | DSO Symbol Version  | Related Packages     |
+| :--------------------- | :------------------ | :------------------- |
+| libc.so.6              | GLIBC_2.38          | glibc-2.39-37        |
+| libz.so.1              | ZLIB_1.2.2          | zlib-ng-2.2.3-1      |
+|                        |                     | zlib-ng-compat-2.2.3-1 |
+
+Optional/Modular Runtime Dependencies (depending on graphics mode):
+
+| DSO Filename           | DSO Symbol Version  | Related Packages     |
+| :--------------------- | :------------------ | :------------------- |
+| libcairo.so.2          |                     |                      |
+| libcairo.so.2.11802.0  |                     | cairo-1.18.2-2       |
+| libGL.so.1             |                     | libglvnd-glx-1:1.7.0-7 |
+|                        |                     | mesa-libGL-24.2.8-2  |
+| libGLU.so.1            |                     | mesa-libGLU-9.0.3-7  |
+
+Transitive/Third-Party Runtime Dependencies (for information only):
+
+| DSO Filename           | DSO Symbol Version  | Related Packages     |
+| :--------------------- | :------------------ | :------------------- |
+| libstdc++.so.6         | CXXABI_1.3.9        | gcc-c++-14.2.1-7     |
+| libstdc++.so.6         | GLIBCXX_3.4         | gcc-c++-14.2.1-7     |
+| libgcc_s.so.1          | GCC_4.2.0           | libgcc_s-14-20250110 |
+| libxml2.so.2           | LIBXML2_2.6.0       | libxml2-2.12.5-5     |
+| libpng16.so.16         | PNG16_0             | libpng-2:1.6.40-8    |
+| liblzma.so.5           | XZ_5.0              | xz-devel-1:5.6.2-4   |
+| libz.so.1              | ZLIB_1.2.9          | zlib-ng-2.2.3-1      |
+|                        |                     | zlib-ng-compat-2.2.3-1 |

appimage/7/Dockerfile

@@ -13,21 +13,24 @@ RUN ls -l /etc/yum.repos.d/ \
     && yum -y update \
     && rm -f /tmp/CentOS-Base.repo.old
 
-# Build Dependencies
-RUN yum install -y cairo-devel freeglut-devel gcc make tcsh
+# Build Dependencies (and dump version to logging)
+RUN yum install -y cairo-devel freeglut-devel gcc make tcsh \
+    && echo "### rpm -qa:" \
+    && rpm -qa | sort \
+    && echo ""
 
 # Tcl/Tk
 WORKDIR /tcl
-RUN curl -L https://prdownloads.sourceforge.net/tcl/tcl8.6.12-src.tar.gz | tar --strip-components=1 -xzC . \
+RUN curl -L https://prdownloads.sourceforge.net/tcl/tcl8.6.16-src.tar.gz | tar --strip-components=1 -xzC . \
     && cd unix \
     && ./configure --prefix=/prefix \
     && make \
     && make install
 
 WORKDIR /tk
-RUN curl -L https://prdownloads.sourceforge.net/tcl/tk8.6.12-src.tar.gz | tar --strip-components=1 -xzC . \
+RUN curl -L https://prdownloads.sourceforge.net/tcl/tk8.6.16-src.tar.gz | tar --strip-components=1 -xzC . \
     && cd unix \
-    && ./configure --prefix=/prefix --with-tcl=/prefix/lib\
+    && ./configure --prefix=/prefix --with-tcl=/prefix/lib \
     && make \
     && make install
 
@@ -49,6 +52,16 @@ RUN ./configure \
     && make -j$(nproc) \
     && make install
 
+# Produce summary of what was created and confirm their DSOs
+RUN echo "### filesystem:" \
+    find /prefix -printf "%y/%M/%m %i/%n %l %u/%U %g/%G %s/%b %T+/%T@\t%p\n"; \
+    ls -lR /prefix; \
+    find /prefix -type f -perm /111 -exec bash -c "echo \#\#\# {}; ldd -v {}" \; 2>/dev/null; \
+    for name in libgcc_s libstdc++ libpng liblzma libxml2 libz libcairo libGL libGLU; do \
+      find /lib64 /usr/lib64 -maxdepth 2 -name "*.so" -name "${name}*" -exec bash -c "echo \#\#\# {}; ldd -v {}" \; 2>/dev/null; \
+    done; \
+    echo "###"
+
 WORKDIR /
 RUN tar -czf /prefix.tar.gz -C ./prefix .
 

appimage/7/Makefile

@@ -0,0 +1,46 @@
+MAGIC_SRC_ROOT = ../..
+RESOURCES := $(shell find ../rsc/ -type f)
+ARCH := $(shell uname -m)
+APPIMAGE = Magic-$(ARCH).AppImage
+VERSION_MAGIC := $(shell cat $(MAGIC_SRC_ROOT)/VERSION)
+VERSION_TSTAMP := $(shell git show -s "--format=%cs" | tr -d '-')
+VERSION_HASH := $(shell git show -s "--format=%h")
+VERSION_NUM ?= $(VERSION_MAGIC)~$(VERSION_TSTAMP)~$(VERSION_HASH)
+VERSION := $(VERSION_NUM)
+
+# Allow CI to override
+APPIMAGETOOL_DOWNLOAD_URL ?= https://github.com/AppImage/appimagetool/releases/download/continuous/appimagetool-x86_64.AppImage
+
+all: $(APPIMAGE)
+
+.PHONY: prefix/bin/magic
+prefix/bin/magic: Dockerfile Makefile
+	@echo "APPIMAGE=$(APPIMAGE)"
+	@echo "VERSION=$(VERSION)"
+	@echo "ARCH=$(ARCH)"
+	@echo "RESOURCES=$(RESOURCES)"
+	rm -rf prefix
+	docker build -t magic_build -f ./Dockerfile $(MAGIC_SRC_ROOT)
+	id=$$(docker create magic_build) ; \
+	docker cp $$id:/prefix ./prefix ; \
+	docker rm -v $$id
+	mkdir -p prefix/lib/tcl8.6.16
+	cp -r prefix/lib/tcl8.6 prefix/lib/tcl8.6.16/library
+
+appimagetool:
+	curl -L "$(APPIMAGETOOL_DOWNLOAD_URL)" > ./appimagetool
+	chmod +x ./appimagetool
+
+$(APPIMAGE): prefix/bin/magic appimagetool $(RESOURCES)
+	cp $(RESOURCES) ./prefix/
+	./appimagetool prefix
+
+PREFIX ?= /usr/local
+install:
+	install $(APPIMAGE) $(PREFIX)/bin/magic
+
+.PHONY: clean
+clean:
+	rm -f *.AppImage
+	rm -f prefix.tar.gz
+	rm -rf prefix

appimage/7/README.md

@@ -0,0 +1,137 @@
+This is an AppImage that runs on all GNU/Linux platforms with:
+
+* FUSE
+    * This excludes non-privileged Docker containers unfortunately, unless pre-extracted.
+* GLIBC 2.17+
+* Cairo 1.15+
+* Supports all Linux x86_64 CPUs
+
+This AppImage build is based on EL7 (via CentOS 7)
+
+CentOS 7 was first released on 07 July 2014 and went end-of-life on 30 June 2024.
+
+# Version Info
+
+See the AppImage main binary file naming, release tag information and AppInfo metadata
+for the exact magic version inside the archive.  When starting AppImage by default the
+Tcl console banner can also provide version information, also using the `version` Tcl
+command.
+
+# Build Info
+
+* Based on CentOS 7 (EL7)
+* Tcl/Tk 8.6.16
+* and Magic 8.x
+* all default modules enabled, but without OpenGL (includes Display drivers cairo/X11)
+
+# FAQ: How to use
+
+Download the *.AppImage file relevant to your platform and run:
+
+```
+chmod +x Magic-x86_64.AppImage
+./Magic-x86_64.AppImage
+```
+
+Example startup with command line options:
+
+```
+./Magic-x86_64.AppImage -d XR -T scmos
+```
+
+# FAQ: How to use (inside docker / podman)
+
+```
+chmod +x Magic-x86_64.AppImage
+
+### Podman or Docker, use :Z when rootless with selinux enabled
+podman run --rm --device /dev/fuse --privileged \
+  -v "$(pwd):/tmp/work:Z" -v "/tmp/.X11-unix/X0:/tmp/.X11-unix/X0:Z" \
+  -e DISPLAY -ti centos:7
+
+### Inside Docker:
+echo "FIXUP yum from vault and update" \
+  && ls -l /etc/yum.repos.d/ \
+  && cp /etc/yum.repos.d/CentOS-Base.repo /tmp/CentOS-Base.repo.old \
+  && sed -e 's/mirror.centos.org/vault.centos.org/g' -i /etc/yum.repos.d/*.repo  \
+  && sed -e 's/^#.*baseurl=http/baseurl=http/g'      -i /etc/yum.repos.d/*.repo  \
+  && sed -e 's/^mirrorlist=http/#mirrorlist=http/g'  -i /etc/yum.repos.d/*.repo  \
+  && diff -u /tmp/CentOS-Base.repo.old /etc/yum.repos.d/CentOS-Base.repo; \
+  yum clean all \
+  && yum -y update \
+  && rm -f /tmp/CentOS-Base.repo.old
+
+yum install -y fuse libX11 cairo
+
+cd /tmp/work
+
+./Magic-x86_64.AppImage -d XR -T scmos
+```
+
+# Building Requirements
+
+* A reasonably recent GNU/Linux host
+* GNU make
+* Docker 20+
+* Git
+* curl
+
+The final build is then packaged into an AppImage using AppImageTool on the host machine.
+
+# Build Instructions
+`make`
+
+# Installation Instructions
+`make install`
+
+# FAQ: Is my CPU supported ?
+
+Supports all x86_64 CPUs.  The Linux ABI in use is the original x86-64 ABI (v1).
+
+Use the command `/lib64/ld-linux-x86-64.so.2 --help` to see which CPUs your
+Linux distribtion supports (and your CPU) look for the word "supported".
+
+# FAQ: The DSO versioning link dependencies?
+
+The information here provides an outline of what versions to expect from EL7
+of the major dependencies, to assist you in a compatibility check with your
+Linux distribution of choice.
+
+The actual versions in our public releases can differ slightly inline with
+the EL7 support compatibility and ABI versioning policies for the support
+lifecycle of the distribution.
+
+The most important items are the Direct Dependencies and the availabilty
+of a suitable graphics DSO as per your '-d' choice.
+
+Direct Runtime Dependencies (from /prefix/**):
+
+| DSO Filename           | DSO Symbol Version  | Related Packages     |
+| :--------------------- | :------------------ | :------------------- |
+| libc.so.6              | GLIBC_2.14          | glibc-2.17-326       |
+| libz.so.1              | ZLIB_1.2.2          | zlib-1.2.7-21        |
+
+Optional/Modular Runtime Dependencies (depending on graphics mode):
+
+| DSO Filename           | DSO Symbol Version  | Related Packages     |
+| :--------------------- | :------------------ | :------------------- |
+| libcairo.so.2          |                     |                      |
+| libcairo.so.2.11512.0  |                     | cairo-1.15.12-4      |
+| libGL.so.1             |                     |                      |
+| libglvnd-glx-1:1.0.1-0 |                     | mesa-libGL-18.3.4-12 |
+| libGLU.so.1            |                     | mesa-libGLU-9.0.0-4  |
+
+Transitive/Third-Party Runtime Dependencies (for information only):
+
+| DSO Filename           | DSO Symbol Version  | Related Packages     |
+| :--------------------- | :------------------ | :------------------- |
+| libc.so.6              | GLIBC_2.35          | glibc-2.17-326       |
+| libstdc++.so.6         | GLIBCXX_3.4         | gcc-4.8.5-44         |
+| libstdc++.so.6         | CXXABI_1.3.9        | gcc-4.8.5-44         |
+| libgcc_s.so.1          |                     |                      |
+| libgcc_s-4.8.5-20150702.so.1 | GCC_4.2.0     | libgcc-4.8.5-44      |
+| libxml2.so.2           | LIBXML2_2.6.0       | libxml2-2.9.1-6      |
+| libpng15.so.15         |                     |                      |
+| libpng15.so.15.13.0    | PNG16_0             | libpng-1:1.5.13-8    |
+| liblzma.so.5           | XZ_5.0              | xz-libs-5.2.2-2      |
+| libz.so.1              | ZLIB_1.2.9          | zlib-1.2.7-21        |

appimage/8/Dockerfile

@@ -0,0 +1,58 @@
+FROM almalinux:8
+
+USER root
+
+# Build Dependencies (and dump version to logging)
+RUN dnf install -y python311 zlib-devel ncurses-devel readline-devel cairo-devel freeglut-devel \
+	mesa-libGLU-devel mesa-libGL-devel libX11-devel libstdc++-devel gcc gcc-c++ make git tcsh \
+    && echo "### rpm -qa:" \
+    && rpm -qa | sort \
+    && echo ""
+#RUN dnf group install -y "Development Tools"
+
+# Tcl/Tk
+WORKDIR /tcl
+RUN curl -L https://prdownloads.sourceforge.net/tcl/tcl8.6.16-src.tar.gz | tar --strip-components=1 -xzC . \
+    && cd unix \
+    && ./configure --prefix=/prefix \
+    && make \
+    && make install
+
+WORKDIR /tk
+RUN curl -L https://prdownloads.sourceforge.net/tcl/tk8.6.16-src.tar.gz | tar --strip-components=1 -xzC . \
+    && cd unix \
+    && ./configure --prefix=/prefix --with-tcl=/prefix/lib \
+    && make \
+    && make install
+
+WORKDIR /prefix/bin
+RUN cp ./wish8.6 ./wish
+RUN cp ./tclsh8.6 ./tclsh
+
+# Magic
+WORKDIR /magic
+COPY . .
+
+RUN ./configure \
+    --prefix=/prefix \
+    --with-tcl=/prefix/lib \
+    --with-tk=/prefix/lib \
+    && make clean \
+    && make database/database.h \
+    && make -j$(nproc) \
+    && make install
+
+# Produce summary of what was created and confirm their DSOs
+RUN echo "### filesystem:" \
+    find /prefix -printf "%y/%M/%m %i/%n %l %u/%U %g/%G %s/%b %T+/%T@\t%p\n"; \
+    ls -lR /prefix; \
+    find /prefix -type f -perm /111 -exec bash -c "echo \#\#\# {}; ldd -v {}" \; 2>/dev/null; \
+    for name in libgcc_s libstdc++ libpng liblzma libxml2 libz libcairo libGL libGLU; do \
+      find /lib64 /usr/lib64 -maxdepth 2 -name "*.so" -name "${name}*" -exec bash -c "echo \#\#\# {}; ldd -v {}" \; 2>/dev/null; \
+    done; \
+    echo "###"
+
+WORKDIR /
+RUN tar -czf /prefix.tar.gz -C ./prefix .
+
+CMD ["/bin/bash"]

appimage/8/Makefile

@@ -0,0 +1,46 @@
+MAGIC_SRC_ROOT = ../..
+RESOURCES := $(shell find ../rsc/ -type f)
+ARCH := $(shell uname -m)
+APPIMAGE = Magic-$(ARCH).AppImage
+VERSION_MAGIC := $(shell cat $(MAGIC_SRC_ROOT)/VERSION)
+VERSION_TSTAMP := $(shell git show -s "--format=%cs" | tr -d '-')
+VERSION_HASH := $(shell git show -s "--format=%h")
+VERSION_NUM ?= $(VERSION_MAGIC)~$(VERSION_TSTAMP)~$(VERSION_HASH)
+VERSION := $(VERSION_NUM)
+
+# Allow CI to override
+APPIMAGETOOL_DOWNLOAD_URL ?= https://github.com/AppImage/appimagetool/releases/download/continuous/appimagetool-x86_64.AppImage
+
+all: $(APPIMAGE)
+
+.PHONY: prefix/bin/magic
+prefix/bin/magic: Dockerfile Makefile
+	@echo "APPIMAGE=$(APPIMAGE)"
+	@echo "VERSION=$(VERSION)"
+	@echo "ARCH=$(ARCH)"
+	@echo "RESOURCES=$(RESOURCES)"
+	rm -rf prefix
+	docker build -t magic_build -f ./Dockerfile $(MAGIC_SRC_ROOT)
+	id=$$(docker create magic_build) ; \
+	docker cp $$id:/prefix ./prefix ; \
+	docker rm -v $$id
+	mkdir -p prefix/lib/tcl8.6.16
+	cp -r prefix/lib/tcl8.6 prefix/lib/tcl8.6.16/library
+
+appimagetool:
+	curl -L "$(APPIMAGETOOL_DOWNLOAD_URL)" > ./appimagetool
+	chmod +x ./appimagetool
+
+$(APPIMAGE): prefix/bin/magic appimagetool $(RESOURCES)
+	cp $(RESOURCES) ./prefix/
+	./appimagetool prefix
+
+PREFIX ?= /usr/local
+install:
+	install $(APPIMAGE) $(PREFIX)/bin/magic
+
+.PHONY: clean
+clean:
+	rm -f *.AppImage
+	rm -f prefix.tar.gz
+	rm -rf prefix

appimage/8/README.md

@@ -0,0 +1,126 @@
+This is an AppImage that runs on all GNU/Linux platforms with:
+
+* FUSE
+    * This excludes non-privileged Docker containers unfortunately, unless pre-extracted.
+* GLIBC 2.28+
+* Cairo 1.15+
+* Supports all Linux x86_64 CPUs
+
+This AppImage build is based on EL8 (via AlmaLinux 8)
+
+AlmaLinux 8 was first released on 20 March 2021, active support ends 31 May 2024,
+security support ends 31 May 2029 (please see AlmaLinux bulletins for
+up-to-date information).
+
+# Version Info
+
+See the AppImage main binary file naming, release tag information and AppInfo metadata
+for the exact magic version inside the archive.  When starting AppImage by default the
+Tcl console banner can also provide version information, also using the `version` Tcl
+command.
+
+* Based on AlmaLinux 8 (EL8)
+* Tcl/Tk 8.6.16
+* and Magic 8.x
+* all default modules enabled (including all Display drivers cairo/X11/OpenGL)
+
+# FAQ: How to use
+
+Download the *.AppImage file relevant to your platform and run:
+
+```
+chmod +x Magic-x86_64.AppImage
+./Magic-x86_64.AppImage
+```
+
+Example startup with command line options:
+
+```
+./Magic-x86_64.AppImage -d XR -T scmos
+```
+
+# FAQ: How to use (inside docker / podman)
+
+```
+chmod +x Magic-x86_64.AppImage
+
+### Podman or Docker, use :Z when rootless with selinux enabled
+podman run --rm --device /dev/fuse --privileged \
+  -v "$(pwd):/tmp/work:Z" -v "/tmp/.X11-unix/X0:/tmp/.X11-unix/X0:Z" \
+  -e DISPLAY -ti almalinux:8
+
+### Inside Docker:
+dnf update -y
+
+dnf install -y fuse libX11 cairo libGL libGLU
+
+cd /tmp/work
+
+./Magic-x86_64.AppImage -d XR -T scmos
+```
+
+# Building Requirements
+
+* A reasonably recent GNU/Linux host
+* GNU make
+* Docker
+* Git
+* curl
+
+The final build is then packaged into an AppImage using AppImageTool on the host machine.
+
+# Build Instructions
+`make`
+
+# Installation Instructions
+`make install`
+
+# FAQ: Is my CPU supported ?
+
+Supports all x86_64 CPUs.  The Linux ABI in use is the original x86-64 ABI (v1).
+
+Use the command `/lib64/ld-linux-x86-64.so.2 --help` to see which CPUs your
+Linux distribtion supports (and your CPU) look for the word "supported".
+
+# FAQ: The DSO versioning link dependencies?
+
+The information here provides an outline of what versions to expect from EL8
+of the major dependencies, to assist you with a compatibility check with your
+Linux distribution of choice.
+
+The actual versions in our public releases can differ slightly inline with
+the EL8 support compatibility and ABI versioning policies for the support
+lifecycle of the distribution.
+
+The most important items are the Direct Dependencies and the availabilty
+of a suitable graphics DSO as per your '-d' choice.
+
+Direct Runtime Dependencies (from /prefix/**):
+
+| DSO Filename           | DSO Symbol Version  | Related Packages     |
+| :--------------------- | :------------------ | :------------------- |
+| libc.so.6              | GLIBC_2.14          | glibc-2.28-251       |
+| libz.so.1              | ZLIB_1.2.2          | zlib-1.2.11-25       |
+
+Optional/Modular Runtime Dependencies (depending on graphics mode):
+
+| DSO Filename           | DSO Symbol Version  | Related Packages     |
+| :--------------------- | :------------------ | :------------------- |
+| libcairo.so.2          |                     |                      |
+| libcairo.so.2.11512.0  |                     | cairo-1.15.12-6      |
+| libGL.so.1             |                     | libglvnd-glx-1:1.3.4-2 |
+|                        |                     | mesa-libGL-23.1.4-4  |
+| libGLU.so.1            |                     | mesa-libGLU-9.0.0-15 |
+
+Transitive/Third-Party Runtime Dependencies (for information only):
+
+| DSO Filename           | DSO Symbol Version  | Related Packages     |
+| :--------------------- | :------------------ | :------------------- |
+| libc.so.6              | GLIBC_2.35          | glibc-2.28-251       |
+| libstdc++.so.6         | GLIBCXX_3.4         | gcc-c++-8.5.0        |
+| libstdc++.so.6         | CXXABI_1.3.9        | gcc-c++-8.5.0        |
+| libgcc_s.so.1          | GCC_4.2.0           | libgcc-8.5.0-26      |
+| libxml2.so.2           |                     | libxml2-2.9.7-19     |
+| libpng16.so.16         | PNG16_0             | libpng-2:1.6.34-5    |
+| liblzma.so.5           |                     | xz-libs-5.2.4-4      |
+| libz.so.1              | ZLIB_1.2.9          | zlib-1.2.11-25       |

appimage/9/Dockerfile

@@ -0,0 +1,59 @@
+FROM almalinux:9
+
+USER root
+
+# Build Dependencies (and dump version to logging)
+RUN dnf install -y python311 zlib-devel ncurses-devel readline-devel cairo-devel freeglut-devel \
+	mesa-libGLU-devel mesa-libGL-devel libX11-devel libstdc++-devel gcc gcc-c++ make git tcsh \
+	zip \
+    && echo "### rpm -qa:" \
+    && rpm -qa | sort \
+    && echo ""
+#RUN dnf group install -y "Development Tools"
+
+# Tcl/Tk
+WORKDIR /tcl
+RUN curl -L https://prdownloads.sourceforge.net/tcl/tcl9.0.1-src.tar.gz | tar --strip-components=1 -xzC . \
+    && cd unix \
+    && ./configure --prefix=/prefix \
+    && make \
+    && make install install-libraries install-msgs install-tzdata
+
+WORKDIR /tk
+RUN curl -L https://prdownloads.sourceforge.net/tcl/tk9.0.1-src.tar.gz | tar --strip-components=1 -xzC . \
+    && cd unix \
+    && ./configure --prefix=/prefix --with-tcl=/prefix/lib \
+    && make \
+    && make install install-libraries
+
+WORKDIR /prefix/bin
+RUN cp ./wish9.0 ./wish
+RUN cp ./tclsh9.0 ./tclsh
+
+# Magic
+WORKDIR /magic
+COPY . .
+
+RUN ./configure \
+    --prefix=/prefix \
+    --with-tcl=/prefix/lib \
+    --with-tk=/prefix/lib \
+    && make clean \
+    && make database/database.h \
+    && make -j$(nproc) \
+    && make install
+
+# Produce summary of what was created and confirm their DSOs
+RUN echo "### filesystem:" \
+    find /prefix -printf "%y/%M/%m %i/%n %l %u/%U %g/%G %s/%b %T+/%T@\t%p\n"; \
+    ls -lR /prefix; \
+    find /prefix -type f -perm /111 -exec bash -c "echo \#\#\# {}; ldd -v {}" \; 2>/dev/null; \
+    for name in libgcc_s libstdc++ libpng liblzma libxml2 libz libcairo libGL libGLU; do \
+      find /lib64 /usr/lib64 -maxdepth 2 -name "*.so" -name "${name}*" -exec bash -c "echo \#\#\# {}; ldd -v {}" \; 2>/dev/null; \
+    done; \
+    echo "###"
+
+WORKDIR /
+RUN tar -czf /prefix.tar.gz -C ./prefix .
+
+CMD ["/bin/bash"]

appimage/9/Makefile

@@ -0,0 +1,46 @@
+MAGIC_SRC_ROOT = ../..
+RESOURCES := $(shell find ../rsc/ -type f)
+ARCH := $(shell uname -m)
+APPIMAGE = Magic-$(ARCH).AppImage
+VERSION_MAGIC := $(shell cat $(MAGIC_SRC_ROOT)/VERSION)
+VERSION_TSTAMP := $(shell git show -s "--format=%cs" | tr -d '-')
+VERSION_HASH := $(shell git show -s "--format=%h")
+VERSION_NUM ?= $(VERSION_MAGIC)~$(VERSION_TSTAMP)~$(VERSION_HASH)
+VERSION := $(VERSION_NUM)
+
+# Allow CI to override
+APPIMAGETOOL_DOWNLOAD_URL ?= https://github.com/AppImage/appimagetool/releases/download/continuous/appimagetool-x86_64.AppImage
+
+all: $(APPIMAGE)
+
+.PHONY: prefix/bin/magic
+prefix/bin/magic: Dockerfile Makefile
+	@echo "APPIMAGE=$(APPIMAGE)"
+	@echo "VERSION=$(VERSION)"
+	@echo "ARCH=$(ARCH)"
+	@echo "RESOURCES=$(RESOURCES)"
+	rm -rf prefix
+	docker build -t magic_build -f ./Dockerfile $(MAGIC_SRC_ROOT)
+	id=$$(docker create magic_build) ; \
+	docker cp $$id:/prefix ./prefix ; \
+	docker rm -v $$id
+	mkdir -p prefix/lib/tcl9.0.1
+	cp -r prefix/lib/tcl9.0 prefix/lib/tcl9.0.1/library
+
+appimagetool:
+	curl -L "$(APPIMAGETOOL_DOWNLOAD_URL)" > ./appimagetool
+	chmod +x ./appimagetool
+
+$(APPIMAGE): prefix/bin/magic appimagetool $(RESOURCES)
+	cp $(RESOURCES) ./prefix/
+	./appimagetool prefix
+
+PREFIX ?= /usr/local
+install:
+	install $(APPIMAGE) $(PREFIX)/bin/magic
+
+.PHONY: clean
+clean:
+	rm -f *.AppImage
+	rm -f prefix.tar.gz
+	rm -rf prefix

appimage/9/README.md

@@ -0,0 +1,128 @@
+This is an AppImage that runs on all GNU/Linux platforms with:
+
+* FUSE
+    * This excludes non-privileged Docker containers unfortunately, unless pre-extracted.
+* GLIBC 2.34+
+* Cairo 1.17+
+* May require runtime CPU matching Linux ABI x86-64-v2 and newer (CPUs with SSE4.2/CX16 via `lscpu`).
+
+This AppImage build is based on EL9 (via AlmaLinux 9)
+
+AlmaLinux 9 was first released on 26 May 2022, full support ends 31 May 2027,
+maintenance support ends 31 May 2032 (please see AlmaLinux bulletins for
+up-to-date information).
+
+# Version Info
+
+See the AppImage main binary file naming, release tag information and AppInfo metadata
+for the exact magic version inside the archive.  When starting AppImage by default the
+Tcl console banner can also provide version information, also using the `version` Tcl
+command.
+
+# Build Info
+
+* Based on AlmaLinux 9 (EL9)
+* Tcl/Tk 9.0.1
+* and Magic 8.x
+* all default modules enabled (including all Display drivers cairo/X11/OpenGL)
+
+# FAQ: How to use
+
+Download the *.AppImage file relevant to your platform and run:
+
+```
+chmod +x Magic-x86_64.AppImage
+./Magic-x86_64.AppImage
+```
+
+Example startup with command line options:
+
+```
+./Magic-x86_64.AppImage -d XR -T scmos
+```
+
+# FAQ: How to use (inside docker / podman)
+
+```
+chmod +x Magic-x86_64.AppImage
+
+### Podman or Docker, use :Z when rootless with selinux enabled
+podman run --rm --device /dev/fuse --privileged \
+  -v "$(pwd):/tmp/work:Z" -v "/tmp/.X11-unix/X0:/tmp/.X11-unix/X0:Z" \
+  -e DISPLAY -ti almalinux:9
+
+### Inside Docker:
+dnf update -y
+
+dnf install -y fuse libX11 cairo libGL libGLU
+
+cd /tmp/work
+
+./Magic-x86_64.AppImage -d XR -T scmos
+```
+
+# Building Requirements
+
+* A reasonably recent GNU/Linux host
+* GNU make
+* Docker
+* Git
+* curl
+
+The final build is then packaged into an AppImage using AppImageTool on the host machine.
+
+# Build Instructions
+`make`
+
+# Installation Instructions
+`make install`
+
+# FAQ: Is my CPU supported ?
+
+This is built with the standard x86_64 Linux ABI version for AlmaLinux 9.
+
+Use the command `/lib64/ld-linux-x86-64.so.2 --help` to see which CPUs your
+Linux distribtion supports (and your CPU) look for the word "supported".
+
+# FAQ: The DSO versioning link dependencies?
+
+The information here provides an outline of what versions to expect from EL9
+of the major dependencies, to assist you in a compatibility check with your
+Linux distribution of choice.
+
+The actual versions in our public releases can differ slightly inline with
+the EL9 support compatibility and ABI versioning policies for the support
+lifecycle of the distribution.
+
+The most important items are the Direct Dependencies and the availabilty
+of a suitable graphics DSO as per your '-d' choice.
+
+Direct Runtime Dependencies (from /prefix/**):
+
+| DSO Filename           | DSO Symbol Version  | Related Packages     |
+| :--------------------- | :------------------ | :------------------- |
+| libc.so.6              | GLIBC_2.34          | glibc-2.34-168       |
+| libz.so.1              | ZLIB_1.2.2          | zlib-1.2.11-40       |
+
+Optional/Modular Runtime Dependencies (depending on graphics mode):
+
+| DSO Filename           | DSO Symbol Version  | Related Packages     |
+| :--------------------- | :------------------ | :------------------- |
+| libcairo.so.2          |                     |                      |
+| libcairo.so.2.11704.0  |                     | cairo-1.17.4-7       |
+| libGL.so.1             |                     | libglvnd-glx-1:1.3.4 |
+|                        |                     | mesa-libGL-24.2.8-2  |
+| libGLU.so.1            |                     | mesa-libGLU-9.0.1    |
+
+Transitive/Third-Party Runtime Dependencies (for information only):
+
+| DSO Filename           | DSO Symbol Version  | Related Packages     |
+| :--------------------- | :------------------ | :------------------- |
+| libc.so.6              | GLIBC_2.35          | glibc-2.34-168       |
+| libstdc++.so.6         | CXXABI_1.3.9        | gcc-c++-11.5.0-5     |
+| libstdc++.so.6         | GLIBCXX_3.4         | gcc-c++-11.5.0-5     |
+| libgcc_s.so.1          | GCC_4.2.0           | libgcc-11.5.0-2      |
+| libxml2.so.2           | LIBXML2_2.6.0       | libxml2-2.9.13-9     |
+| libpng16.so.16         | PNG16_0             | ibpng-2:1.6.37-12    |
+| liblzma.so.5           | XZ_5.0              | xz-libs-5.2.5-8      |
+| libz.so.1              | ZLIB_1.2.9          | zlib-1.2.11-40       |

appimage/Makefile

@@ -1,33 +0,0 @@
-RESOURCES = $(shell find rsc/ -type f)
-ARCH = $(shell uname -m)
-APPIMAGE = Magic-$(ARCH).AppImage
-
-all: $(APPIMAGE)
-
-.PHONY: prefix/bin/magic
-prefix/bin/magic: Dockerfile Makefile
-	rm -rf prefix
-	docker build -t magic_build -f ./Dockerfile ..
-	id=$$(docker create magic_build) ; \
-	docker cp $$id:/prefix ./prefix ; \
-	docker rm -v $$id
-	mkdir -p prefix/lib/tcl8.6.12
-	cp -r prefix/lib/tcl8.6 prefix/lib/tcl8.6.12/library
-
-appimagetool:
-	curl -L https://github.com/AppImage/AppImageKit/releases/download/13/appimagetool-x86_64.AppImage > ./appimagetool
-	chmod +x ./appimagetool
-
-$(APPIMAGE): prefix/bin/magic appimagetool $(RESOURCES) 
-	cp $(RESOURCES) ./prefix
-	./appimagetool prefix
-
-PREFIX ?= /usr/local
-install:
-	install $(APPIMAGE) $(PREFIX)/bin/magic
-
-.PHONY: clean
-clean:
-	rm -f *.AppImage
-	rm -f prefix.tar.gz
-	rm -rf prefix

appimage/README.md

@@ -1,24 +0,0 @@
-This is an AppImage that runs on all GNU/Linux platforms with:
-
-* FUSE
-    * This excludes non-privileged Docker containers unfortunately, unless pre-extracted.
-* GLIBC 2.17+
-* Cairo 1.8+
-
-That's most Linux distributions released in 2016 or later.
-
-# Build Info
-A Dockerfile on CentOS 7 (needed for older glibc) image builds Tcl, Tk and Magic.
-
-The final build is then packaged into an AppImage using AppImageTool on the host machine.
-
-# Building Requirements
-* A reasonably recent GNU/Linux host
-* Docker 20+
-* curl
-
-# Build Instructions
-`make`
-
-# Installation Instructions
-`make install`

appimage/rsc/AppRun

@@ -1,7 +1,39 @@
-#!/bin/sh
+#!/usr/bin/env bash
 export CURDIR=$(dirname $(readlink -f "${0}"))
+
 export PATH="${CURDIR}/bin":$PATH
 export LD_LIBRARY_PATH=${CURDIR}/lib:$LD_LIBRARY_PATH
+
 export CAD_ROOT="${CURDIR}/lib"
 export MAGIC_WISH="${CURDIR}/bin/wish"
-exec "${CURDIR}/bin/magic" $@
+
+function my_echo() {
+    if [ "$MAGIC_VERBOSE" != "0" ]
+    then
+        echo -- $@
+    fi
+}
+
+# Attempt to set by default a valid 'ulimit -n' based on TCL version this
+#  will automatically apply valid limit inside docker running processes.
+if [ "X${MAGIC_ULIMIT_NOFILE:+set}" = "X" ] # not set to something
+then
+    if $MAGIC_WISH "${CURDIR}/version_check.tcl" | grep -q "=8\." # only needed for tcl8
+    then
+        if [ $(ulimit -Sn) -gt 1024 ] # only reduce >1024 to 1024
+        then
+            MAGIC_ULIMIT_NOFILE=1024
+            my_echo "# ulimit -Sn reduced from $(ulimit -Sn) to $MAGIC_ULIMIT_NOFILE"
+        fi
+    fi
+fi
+
+if [ "X$MAGIC_ULIMIT_NOFILE" != "X" ] # non empty
+then
+    # Inform user we did this and hint at how to customize
+    my_echo "ulimit -Sn $MAGIC_ULIMIT_NOFILE # use \$MAGIC_ULIMIT_NOFILE to customize"
+    ulimit -Sn $MAGIC_ULIMIT_NOFILE
+fi
+
+my_echo "# Starting Magic"
+exec "${CURDIR}/bin/magic" "$@"

appimage/rsc/version_check.tcl

@@ -0,0 +1,4 @@
+# Usage: wish version_check.tcl 
+puts "tcl_version=$tcl_version"
+puts "tk_version=$tk_version"
+exit 0

bplane/bpBins.c

@@ -93,7 +93,7 @@ static BinArray *bpBinArrayNew(int dx,      /* x diameter of bins */
 
   /* allocate array */
   size = sizeof(BinArray) + numBins*(sizeof(void *));
-  new = (BinArray *)callocMagic(size);
+  new = (BinArray *)callocMagic(1, size);
 
   /* initial */
   new->ba_bbox = *bbox;

bplane/bpDump.c

@@ -78,6 +78,7 @@ void bpDumpRect(Rect *r)
     fprintf(stderr,"%d",
 	    r->r_ytop);
   }
+#ifdef CIF_MODULE
   else
   {
     float oscale;
@@ -93,6 +94,7 @@ void bpDumpRect(Rect *r)
     fprintf(stderr,"%f",
 	    oscale * (float)r->r_ytop);
   }
+#endif
 }
 
 /*
@@ -170,6 +172,7 @@ static void bpBinArrayDump(BinArray *ba, int indent)
     fprintf(stderr,"{dx %d} {dy %d} ",
 	    dx,dy);
   }
+#ifdef CIF_MODULE
   else
   {
     float oscale;
@@ -182,6 +185,7 @@ static void bpBinArrayDump(BinArray *ba, int indent)
     fprintf(stderr,"{dy %f} ",
 	    (float)dy * oscale);
   }
+#endif
     fprintf(stderr,"{dimX %d} {dimY %d} {  bbox ",
 	  dimX,
 	  dimY);

bplane/bpEnum.c

@@ -50,9 +50,9 @@
  */
 void BPEnumInit(BPEnum *bpe,   /* enum to initialize */
 		BPlane *bp,
-		Rect *area,    /* search area */
+		const Rect *area,    /* search area */
 		int match,
-		char *id)      /* for debugging */
+		const char *id)      /* for debugging */
 {
   bool inside = FALSE;
   bpe->bpe_plane = bp;

bplane/bpEnum.h

@@ -25,8 +25,8 @@
 //
 // ************************************************************************
 
-#ifndef _BPENUM_H
-#define _BPENUM_H
+#ifndef _MAGIC__BPLANE__BPENUM_H
+#define _MAGIC__BPLANE__BPENUM_H
 
 /* bpEnum.h --
  *
@@ -534,4 +534,4 @@ static __inline__ void *BPEnumNext(BPEnum *bpe)
   }
 }
 
-#endif /* _BPENUM_H */
+#endif /* _MAGIC__BPLANE__BPENUM_H */

bplane/bpOpaque.h

@@ -27,12 +27,12 @@
 
 
 
-#ifndef _BPOPAQUE_H
-#define _BPOPAQUE_H
+#ifndef _MAGIC__BPLANE__BPOPAQUE_H
+#define _MAGIC__BPLANE__BPOPAQUE_H
 
-#ifndef _IHASH_H
+#ifndef _MAGIC__UTILS__IHASH_H
 #include "utils/ihash.h"
-#endif /* _IHASH_H */
+#endif
 
 /*
  * bpOpaque.h --
@@ -182,7 +182,7 @@ typedef struct bpenum
   BPlane *bpe_plane;           /* plane being searched */
   Rect    bpe_srchArea;        /* area being searched */
   int     bpe_match;           /* match criteria */
-  char   *bpe_id;              /* for debug */
+  const char *bpe_id;          /* for debug */
   int     bpe_subBinMinX;
   int     bpe_subBinMinY;      /* consider subbinning
 				* for bins bigger than this.
@@ -192,4 +192,4 @@ typedef struct bpenum
   BPStack bpe_stack[10000];    /* stack for tree traversal during enum */
 } BPEnum;
 
-#endif /* _BPOPAQUE_H */
+#endif /* _MAGIC__BPLANE__BPOPAQUE_H */

bplane/bplane.h

@@ -27,8 +27,8 @@
 
 
 
-#ifndef _BPLANE_H
-#define _BPLANE_H
+#ifndef _MAGIC__BPLANE__BPLANE_H
+#define _MAGIC__BPLANE__BPLANE_H
 
 /*
  * bplane.h --
@@ -185,9 +185,9 @@ extern void BPEnumInit(BPEnum *bpe, /* this procedure initializes this
 				     * enumeration.
 				     */
 		       BPlane *bp, /* bplane to search */
-		       Rect *area, /* area to search */
+		       const Rect *area, /* area to search */
 		       int match,  /* see below */
-		       char *id);  /* for debugging */
+		       const char *id);  /* for debugging */
 /* match values */
 
   /* enum all elements in the bplane (area arg must be null) */
@@ -232,4 +232,4 @@ BPStat(BPlane *bp,
        int *totUnbinned,     /* ret tot num of e's not binned */
        int *maxDepth);       /* ret max bin array depth */
 
-#endif /* _BPLANE_H */
+#endif /* _MAGIC__BPLANE__BPLANE_H */

bplane/bplaneInt.h

@@ -33,8 +33,8 @@
  * This file defines constants and datastructures used internally by the
  * bplane module, but not exported to the rest of the world.
  */
-#ifndef _BPLANEINT_H
-#define _BPLANEINT_H
+#ifndef _MAGIC__BPLANE__BPLANEINT_H
+#define _MAGIC__BPLANE__BPLANEINT_H
 
 /* Tcl linked Parameters */
 extern int bpMinBAPop;         /* don't sub(bin) when count less than this
@@ -79,4 +79,4 @@ extern Plane *bpTestSnowTile(int size, bool trace);
 
 extern int bpRand(int min, int max);
 
-#endif /* _BPLANEINT_H */
+#endif /* _MAGIC__BPLANE__BPLANEINT_H */

calma/CalmaRdcl.c

@@ -53,6 +53,7 @@ int calmaNonManhattan;
 int CalmaFlattenLimit = 10;
 int NameConvertErrors = 0;
 bool CalmaRewound = FALSE;
+bool CalmaRecordPaths = FALSE;
 TileTypeBitMask *CalmaMaskHints = NULL;
 
 extern HashTable calmaDefInitHash;
@@ -245,7 +246,9 @@ calmaExact(void)
     int pNum;
     Plane *newplane;
     Plane **parray;
-    int gdsCopyPaintFunc(Tile *tile, GDSCopyRec *gdsCopyRec);	/* Forward reference */
+
+    /* Forward reference */
+    int gdsCopyPaintFunc(Tile *tile, TileType dinfo, GDSCopyRec *gdsCopyRec);
 
     parray = (Plane **)mallocMagic(MAXCIFRLAYERS * sizeof(Plane *));
 
@@ -387,6 +390,15 @@ calmaParseStructure(
     he = HashFind(&calmaDefInitHash, strname);
     if ((def = (CellDef *)HashGetValue(he)) != NULL)
     {
+	if (def->cd_flags & CDPRELOADED)
+	{
+	    /* Cell definition was read ahead due to option "flatten"	*/
+	    /* or "flatglob".  Do not complain about seeing it again.	*/
+	    def->cd_flags &= ~CDPRELOADED;
+	    calmaNextCell();
+	    return TRUE;
+	}
+
 	if (def->cd_flags & CDPROCESSEDGDS)
 	{
 	    /* If cell definition was marked as processed, then skip	*/
@@ -396,6 +408,7 @@ calmaParseStructure(
 
 	    if (!CalmaPostOrder && !CalmaRewound)
 	    {
+		cifReadCellDef = def;
 		CalmaReadError("Cell \"%s\" was already defined in this file.\n",
 				strname);
 		CalmaReadError("Ignoring duplicate definition\n");
@@ -407,6 +420,7 @@ calmaParseStructure(
 	{
 	    char *newname;
 
+	    cifReadCellDef = def;
 	    CalmaReadError("Cell \"%s\" was already defined in this file.\n",
 				strname);
 	    newname = (char *)mallocMagic(strlen(strname) + 20);
@@ -492,28 +506,33 @@ calmaParseStructure(
 
     if (CalmaReadOnly || predefined)
     {
+	PropertyRecord *proprec;
 	char cstring[1024];
 
-	/* Writing the file position into a string is slow, but */
-	/* it prevents requiring special handling when printing	*/
-	/* out the properties.					*/
-
-	char *fpcopy = (char *)mallocMagic(20);
-	char *fncopy;
-
 	/* Substitute variable for PDK path or ~ for home directory	*/
 	/* the same way that cell references are handled in .mag files.	*/
 	DBPathSubstitute(filename, cstring, cifReadCellDef);
-	fncopy = StrDup(NULL, cstring);
-	sprintf(fpcopy, "%"DLONG_PREFIX"d", (dlong) filepos);
-	DBPropPut(cifReadCellDef, "GDS_START", (ClientData)fpcopy);
 
-	fpcopy = (char *)mallocMagic(20);
+	proprec = (PropertyRecord *)mallocMagic(sizeof(PropertyRecord));
+	proprec->prop_type = PROPERTY_TYPE_DOUBLE;
+	proprec->prop_len = 1;
+	proprec->prop_value.prop_double[0] = filepos;
+	DBPropPut(cifReadCellDef, "GDS_START", (ClientData)proprec);
+
 	filepos = FTELL(calmaInputFile);
-	sprintf(fpcopy, "%"DLONG_PREFIX"d", (dlong) filepos);
-	DBPropPut(cifReadCellDef, "GDS_END", (ClientData)fpcopy);
 
-	DBPropPut(cifReadCellDef, "GDS_FILE", (ClientData)fncopy);
+	proprec = (PropertyRecord *)mallocMagic(sizeof(PropertyRecord));
+	proprec->prop_type = PROPERTY_TYPE_DOUBLE;
+	proprec->prop_len = 1;
+	proprec->prop_value.prop_double[0] = filepos;
+	DBPropPut(cifReadCellDef, "GDS_END", (ClientData)proprec);
+
+	proprec = (PropertyRecord *)mallocMagic(sizeof(PropertyRecord) - 7 +
+		strlen(cstring));
+	proprec->prop_type = PROPERTY_TYPE_STRING;
+	proprec->prop_len = 1;
+	strcpy(proprec->prop_value.prop_string, cstring);
+	DBPropPut(cifReadCellDef, "GDS_FILE", (ClientData)proprec);
 
     	if (predefined)
     	{
@@ -740,6 +759,7 @@ calmaParseElement(
 int
 calmaEnumFunc(
     Tile *tile,
+    TileType dinfo,
     int *plane)
 {
     return 1;
@@ -769,20 +789,22 @@ calmaElementSref(
     char *filename)
 {
     int nbytes, rtype, cols, rows, nref, n, i, savescale;
-    int xlo, ylo, xhi, yhi, xsep, ysep;
-    bool madeinst = FALSE;
+    int xlo, ylo, xhi, yhi, xsep, ysep, angle;
+    bool madeinst = FALSE, rotated = FALSE;
     char *sname = NULL;
     bool isArray = FALSE;
+    bool dolookahead = FALSE;
     Transform trans, tinv;
     Point refarray[3], refunscaled[3], p;
     CellUse *use;
     CellDef *def;
-    int gdsCopyPaintFunc(Tile *tile, GDSCopyRec *gdsCopyRec);	/* Forward reference */
-    int gdsHasUses(CellUse *use, ClientData clientdata);		/* Forward reference */
-    /* Added by NP */
     char *useid = NULL, *arraystr = NULL;
     int propAttrType;
 
+    /* Forward reference */
+    int gdsCopyPaintFunc(Tile *tile, TileType dinfo, GDSCopyRec *gdsCopyRec);
+    int gdsHasUses(CellUse *use, ClientData clientdata);
+
     /* Skip CALMA_ELFLAGS, CALMA_PLEX */
     calmaSkipSet(calmaElementIgnore);
 
@@ -798,7 +820,38 @@ calmaElementSref(
      */
 
     def = calmaLookCell(sname);
-    if (!def && (CalmaPostOrder || CalmaFlattenUses || (CalmaFlattenUsesByName != NULL)))
+
+    /*
+     * If the "flatten" option is set, then we always have to seek
+     * ahead and read the structure in order to determine if it
+     * meets the requirement of being flattened or not.  If the
+     * "flatglob" option is set, then we need to read ahead and
+     * read the cell definition so that it can be flatten.  This
+     * requires pattern-matching the cell def.
+     */
+
+    dolookahead = (CalmaPostOrder || CalmaFlattenUses) ? TRUE : FALSE;
+    if ((!dolookahead) && (CalmaFlattenUsesByName != NULL))
+    {
+	char *pattern;
+
+	i = 0;
+	while (TRUE)
+	{
+	    pattern = CalmaFlattenUsesByName[i];
+	    if (pattern == NULL) break;
+	    i++;
+
+	    /* Check pattern against strname */
+	    if (Match(pattern, sname))
+	    {
+		dolookahead = TRUE;
+		break;
+	    }
+	}
+    }
+
+    if (!def && dolookahead)
     {
 	/* Force the GDS parser to read the cell definition in
 	 * post-order.  If cellname "sname" is not defined before
@@ -832,6 +885,7 @@ calmaElementSref(
 	    FSEEK(calmaInputFile, originalFilePos, SEEK_SET);
 	    cifReadCellDef = calmaLookCell(currentSname);
 	    def = calmaLookCell(sname);
+	    def->cd_flags |= CDPRELOADED;
 	    cifCurReadPlanes = savePlanes;
 	    calmaLayerHash = OrigCalmaLayerHash;
 	    if (crsMultiplier != cifCurReadStyle->crs_multiplier)
@@ -936,17 +990,73 @@ calmaElementSref(
 	refarray[2].p_x = refarray[2].p_y = 0;
     }
 
+    /* If the array is given an angle, then the meaning of rows and
+     * columns needs to be swapped for the purpose of ignoring
+     * X or Y values in the case of a 1-row or 1-column entry.
+     */
+    angle = GeoTransAngle(&trans, 0);
+    if ((angle == 90) || (angle == 270) || (angle == -90) || (angle == -270))
+	rotated = TRUE;
+
     /* If this is a cell reference, then we scale to magic coordinates
      * and place the cell in the magic database.  However, if this is
      * a cell to be flattened a la "gds flatten", then we keep the GDS
      * coordinates, and don't scale to the magic database.
+     *
+     * NOTE:  Scaling everything in the middle or reading array data
+     * and then retroactively adjusting the array data read earlier
+     * is problematic, and probably incorrect.
      */
 
+  
+    for (n = 0; n < nref; n++)
+    {
+	savescale = calmaReadScale1;
+
+	/* If there is only one column, then X data in the 2nd or 3rd
+	 * entry is irrelevant.  If there is only one row, then Y data
+	 * in the 2nd or 3rd entry is irrelevant.  Prevent issues caused
+	 * by incorrect/uninitialized data in these positions by ignoring
+	 * them as needed.
+	 */
+
+	if ((n > 0) && ((!rotated && (rows == 1)) || (rotated && (cols == 1))))
+	{
+	    calmaReadX(&refarray[n], 1);
+	    calmaSkipBytes(4);
+	    refarray[n].p_y = refarray[0].p_y;
+	}
+	else if ((n > 0) && ((!rotated && (cols == 1)) || (rotated && (rows == 1))))
+	{
+	    calmaSkipBytes(4);
+	    calmaReadY(&refarray[n], 1);
+	    refarray[n].p_x = refarray[0].p_x;
+	}
+	else
+	    calmaReadPoint(&refarray[n], 1);
+
+	if (savescale != calmaReadScale1)
+	{
+	    /* Scale changed, so update previous points read */
+	    int newscale = calmaReadScale1 / savescale;
+	    for (i = 0; i < n; i++)
+	    {
+		refarray[i].p_x *= newscale;
+		refarray[i].p_y *= newscale;
+	    }
+	}
+
+	if (FEOF(calmaInputFile))
+	    return -1;
+    }
+
+    for (n = 0; n < nref; n++)
+	refunscaled[n] = refarray[n];	// Save for CDFLATGDS cells
+
     for (n = 0; n < nref; n++)
     {
 	savescale = cifCurReadStyle->crs_scaleFactor;
-	calmaReadPoint(&refarray[n], 1);
-	refunscaled[n] = refarray[n];	// Save for CDFLATGDS cells
+
 	refarray[n].p_x = CIFScaleCoord(refarray[n].p_x, COORD_EXACT);
 	if (savescale != cifCurReadStyle->crs_scaleFactor)
 	{
@@ -967,9 +1077,6 @@ calmaElementSref(
 	    }
 	    refarray[n].p_x *= (savescale / cifCurReadStyle->crs_scaleFactor);
 	}
-
-	if (FEOF(calmaInputFile))
-	    return -1;
     }
 
     /* Skip remainder */
@@ -1245,27 +1352,28 @@ gdsHasUses(
 int
 gdsCopyPaintFunc(
     Tile *tile,
+    TileType dinfo,
     GDSCopyRec *gdsCopyRec)
 {
     int pNum;
-    TileType dinfo;
+    TileType newdinfo;
     Rect sourceRect, targetRect;
     Transform *trans = gdsCopyRec->trans;
     Plane *plane = gdsCopyRec->plane;
 
-    dinfo = TiGetTypeExact(tile);
+    newdinfo = TiGetTypeExact(tile) | dinfo;
 
     if (trans)
     {
 	TiToRect(tile, &sourceRect);
 	GeoTransRect(trans, &sourceRect, &targetRect);
 	if (IsSplit(tile))
-	    dinfo = DBTransformDiagonal(TiGetTypeExact(tile), trans);
+	    newdinfo = DBTransformDiagonal(TiGetTypeExact(tile) | dinfo, trans);
     }
     else
 	TiToRect(tile, &targetRect);
 
-    DBNMPaintPlane(plane, dinfo, &targetRect, CIFPaintTable,
+    DBNMPaintPlane(plane, newdinfo, &targetRect, CIFPaintTable,
 		(PaintUndoInfo *)NULL);
 
     return 0;
@@ -1384,13 +1492,18 @@ calmaFindCell(
 	}
 	else
 	{
-	    TxPrintf("Warning:  cell %s already existed before reading GDS!\n",
-			name);
 	    if (CalmaNoDuplicates)
 	    {
+		TxPrintf("Note:  cell %s already existed before reading GDS.\n",
+			name);
 		if (predefined) *predefined = TRUE;
 	    	TxPrintf("Using pre-existing cell definition\n");
 	    }
+	    else
+	    {
+		TxPrintf("Warning:  cell %s already existed before reading GDS!\n",
+			name);
+	    }
 	    if (was_called) *was_called = TRUE;
 	}
 	HashSetValue(h, def);

calma/CalmaRdpt.c

@@ -58,7 +58,7 @@ extern int CalmaPathCount;
 extern HashTable calmaDefInitHash;
 
 extern void calmaLayerError(char *mesg, int layer, int dt);
-bool calmaReadPath(CIFPath **pathheadpp, int iscale);
+CIFPath *calmaReadPath(int iscale);
 
 /*
  * ----------------------------------------------------------------------------
@@ -114,6 +114,8 @@ calmaInputRescale(
 /*
  * ----------------------------------------------------------------------------
  *
+ * calmaReadX ---
+ * calmaReadY ---
  * calmaReadPoint ---
  *
  * Read a point from the input.
@@ -132,11 +134,17 @@ calmaInputRescale(
  *	encountered, then everything in the GDS planes is rescaled
  *	to match.
  *
+ * Notes:
+ *	This routine has been split into individual X and Y reads so that
+ *	array data can be read while ignoring offset information when there
+ *	is only one row or column;  otherwise, bad or uninitialized data
+ *	in the record can cause unnecessary and incorrect scaling.
+ *
  * ----------------------------------------------------------------------------
  */
 
 void
-calmaReadPoint(
+calmaReadX(
     Point *p,
     int iscale)
 {
@@ -163,6 +171,15 @@ calmaReadPoint(
 	}
     }
     p->p_x /= calmaReadScale2;
+}
+
+
+void
+calmaReadY(
+    Point *p,
+    int iscale)
+{
+    int rescale;
 
     READI4((p)->p_y);
     p->p_y *= (calmaReadScale1 * iscale);
@@ -188,6 +205,15 @@ calmaReadPoint(
     p->p_y /= calmaReadScale2;
 }
 
+void
+calmaReadPoint(
+    Point *p,
+    int iscale)
+{
+    calmaReadX(p, iscale);
+    calmaReadY(p, iscale);
+}
+
 
 /*
  * ----------------------------------------------------------------------------
@@ -213,7 +239,7 @@ calmaElementBoundary(void)
     LinkedRect *rp;
     Plane *plane;
     CellUse *use;
-    CellDef *savedef, *newdef = NULL;
+    CellDef *savedef = NULL, *newdef = NULL;
 
     /* Skip CALMA_ELFLAGS, CALMA_PLEX */
     calmaSkipSet(calmaElementIgnore);
@@ -237,7 +263,8 @@ calmaElementBoundary(void)
 	plane = cifCurReadPlanes[ciftype];
 
     /* Read the path itself, building up a path structure */
-    if (!calmaReadPath(&pathheadp, (plane == NULL) ? 0 : 1))
+    pathheadp = calmaReadPath((plane == NULL) ? 0 : 1);
+    if (pathheadp == NULL)
     {
 	if (plane != NULL)
 	    CalmaReadError("Error while reading path for boundary/box; ignored.\n");
@@ -257,7 +284,7 @@ calmaElementBoundary(void)
     if ((CalmaSubcellPolygons != CALMA_POLYGON_NONE) && (calmaNonManhattan > 0))
     {
 	/* Place the polygon in its own subcell */
-	char newname[16];
+	char newname[20];
 	HashEntry *he;
 
 	savedef = cifReadCellDef;
@@ -359,12 +386,14 @@ calmaElementBoundary(void)
     }
 
     /* Paint the rectangles (if any) */
+    free_magic1_t mm1 = freeMagic1_init();
     for (; rp != NULL ; rp = rp->r_next)
     {
 	if (plane)
 	    DBPaintPlane(plane, &rp->r_r, CIFPaintTable, (PaintUndoInfo *)NULL);
-	freeMagic((char *) rp);
+	freeMagic1(&mm1, (char *) rp);
     }
+    freeMagic1_end(&mm1);
 
     if (cifCurReadPlanes == cifEditCellPlanes)
     {
@@ -508,11 +537,10 @@ calmaElementPath(void)
     int layer, dt, width, pathtype, ciftype, savescale;
     int xmin, ymin, xmax, ymax, temp;
     CIFPath *pathheadp, *pathp, *previousp;
-    Rect segment;
     Plane *plane;
     int first,last;
     CellUse *use;
-    CellDef *savedef, *newdef = NULL;
+    CellDef *savedef = NULL, *newdef = NULL;
 
     /* Skip CALMA_ELFLAGS, CALMA_PLEX */
     calmaSkipSet(calmaElementIgnore);
@@ -595,7 +623,8 @@ calmaElementPath(void)
 
     /* Read the points in the path */
     savescale = calmaReadScale1;
-    if (!calmaReadPath(&pathheadp, 2))
+    pathheadp = calmaReadPath(2);
+    if (pathheadp == NULL)
     {
 	CalmaReadError("Improper path; ignored.\n");
 	return;
@@ -688,7 +717,12 @@ calmaElementPath(void)
 	    }
 	}
 
-	CIFPropRecordPath(cifReadCellDef, pathheadp, TRUE, "path");
+	/* If requested by command option, record the path centerline as a
+	 * property of the cell def.
+	 */
+	if (CalmaRecordPaths)
+	    CIFPropRecordPath(cifReadCellDef, pathheadp, TRUE, "path");
+
 	CIFPaintWirePath(pathheadp, width,
 		(pathtype == CALMAPATH_SQUAREFLUSH || pathtype == CALMAPATH_CUSTOM) ?
 		FALSE : TRUE, plane, CIFPaintTable, (PaintUndoInfo *)NULL);
@@ -1098,26 +1132,24 @@ calmaElementText(void)
  * centerline, to avoid roundoff errors.
  *
  * Results:
- *	TRUE is returned if the path was parsed successfully,
- *	FALSE otherwise.
+ *	non-NULL CIFPath* the caller takes ownership of
+ *	if the path was parsed successfully, otherwise NULL.
  *
  * Side effects:
- *	Modifies the parameter pathheadpp to point to the path
- *	that is constructed.
+ *	None
  *
  * ----------------------------------------------------------------------------
  */
 
-bool
+CIFPath *
 calmaReadPath(
-    CIFPath **pathheadpp,
     int iscale)
 {
-    CIFPath path, *pathtailp, *newpathp;
+    CIFPath path, *pathheadp, *pathtailp, *newpathp;
     int nbytes, rtype, npoints, savescale;
     bool nonManhattan = FALSE;
 
-    *pathheadpp = (CIFPath *) NULL;
+    pathheadp = (CIFPath *) NULL;
     pathtailp = (CIFPath *) NULL;
     path.cifp_next = (CIFPath *) NULL;
 
@@ -1126,12 +1158,12 @@ calmaReadPath(
     if (nbytes < 0)
     {
 	CalmaReadError("EOF when reading path.\n");
-	return (FALSE);
+	return (NULL);
     }
     if (rtype != CALMA_XY)
     {
 	calmaUnexpected(CALMA_XY, rtype);
-	return (FALSE);
+	return (NULL);
     }
 
     /* Read this many points (pairs of four-byte integers) */
@@ -1142,7 +1174,7 @@ calmaReadPath(
 	calmaReadPoint(&path.cifp_point, iscale);
 	if (savescale != calmaReadScale1)
 	{
-	    CIFPath *phead = *pathheadpp;
+	    CIFPath *phead = pathheadp;
 	    int newscale = calmaReadScale1 / savescale;
 	    while (phead != NULL)
 	    {
@@ -1157,8 +1189,8 @@ calmaReadPath(
 	}
 	if (FEOF(calmaInputFile))
 	{
-	    CIFFreePath(*pathheadpp);
-	    return (FALSE);
+	    CIFFreePath(pathheadp);
+	    return (NULL);
 	}
 
 	if (iscale != 0)
@@ -1166,7 +1198,7 @@ calmaReadPath(
 	    newpathp = (CIFPath *) mallocMagic((unsigned) (sizeof (CIFPath)));
 	    *newpathp = path;
 
-	    if (*pathheadpp)
+	    if (pathheadp)
 	    {
 		/*
 		 * Check that this segment is Manhattan.  If not, remember the
@@ -1187,11 +1219,11 @@ calmaReadPath(
 		}
 		pathtailp->cifp_next = newpathp;
 	    }
-	    else *pathheadpp = newpathp;
+	    else pathheadp = newpathp;
 	    pathtailp = newpathp;
 	}
     }
-    return (*pathheadpp != NULL);
+    return (pathheadp);
 }
 
 /*

calma/CalmaRead.c

@@ -112,7 +112,7 @@ bool CalmaUnique = FALSE;		/* If TRUE, then if a cell exists in
 extern bool CalmaDoLibrary;		/* Also used by GDS write */
 
 extern void calmaUnexpected(int wanted, int got);
-extern int calmaWriteInitFunc(CellDef *def);
+extern int calmaWriteInitFunc(CellDef *def, ClientData cdata);	/* UNUSED */
 
 /*
  * Scaling.
@@ -613,20 +613,23 @@ CalmaTechInit(void)
     ASSERT(sizeof(FourByteInt)==4, "definition in calmaInt.h");
     ASSERT(sizeof(TwoByteInt)==2, "definition in calmaInt.h");
 
-    /* NOTE:  Enable the code below when CalmaContactArrays	*/
-    /* behaves like the non-arrayed function and can be enabled	*/
-    /* by default.						*/
-#if 0
+    /* NOTE:  Add "$$*$$" to the default "flatglob" value	*/
+    /* when CalmaContactArrays behaves like the non-arrayed	*/
+    /* function and can be enabled by default.			*/
+
     /* Initialize CalmaFlattenByName to have one entry for	*/
-    /* "$$*$$" to match the name style used by the contact	*/
-    /* array cell generation.  This can be overridden by the	*/
-    /* "gds flatglob none" command option.			*/
+    /* "*_CDNS_*" to match the name style used by many foundry	*/
+    /* cells and which corresponds to pcells that often split	*/
+    /* layers between cells in ways that magic can't cope with;	*/
+    /* and whose original parameterized functions cannot be	*/
+    /* recovered by magic anyway.  When necessary, this default	*/
+    /* can be overridden by the	"gds flatglob none" command	*/
+    /* option.							*/
 
     if (CalmaFlattenUsesByName == (char **)NULL)
     {
 	CalmaFlattenUsesByName = (char **)mallocMagic(2 * sizeof(char *));
-	*CalmaFlattenUsesByName = StrDup((char **)NULL, "$$*$$");
+	*CalmaFlattenUsesByName = StrDup((char **)NULL, "*_CDNS_*");
 	*(CalmaFlattenUsesByName + 1) = NULL;
     }
-#endif
 }

calma/CalmaWrite.c

@@ -28,9 +28,15 @@ static const char rcsid[] __attribute__ ((unused)) ="$Header: /usr/cvsroot/magic
 #include <ctype.h>
 #include <sys/types.h>
 #include <arpa/inet.h>	/* for htons() */
-#include <time.h>       /* since C89 */
-#ifdef HAVE_SYS_TIME_H
-#include <sys/time.h>
+#ifdef TIME_WITH_SYS_TIME
+# include <sys/time.h>
+# include <time.h>
+#else
+# ifdef HAVE_SYS_TIME_H
+#  include <sys/time.h>
+# else
+#  include <time.h>
+# endif
 #endif
 
 #include "utils/magic.h"
@@ -38,6 +44,7 @@ static const char rcsid[] __attribute__ ((unused)) ="$Header: /usr/cvsroot/magic
 #include "utils/geometry.h"
 #include "tiles/tile.h"
 #include "utils/utils.h"
+#include "utils/magic_zlib.h"
 #include "utils/hash.h"
 #include "database/database.h"
 #include "database/databaseInt.h"
@@ -84,19 +91,19 @@ int  CalmaCompression = 0;	/* Output file compression level (0 = uncompressed) *
 
 typedef struct {
    FILE *f;		/* File stream for output		*/
-   Rect *area;		/* Clipping area, in GDS coordinates	*/
+   const Rect *area;	/* Clipping area, in GDS coordinates	*/
    int type;		/* Layer index				*/
 } calmaOutputStruct;
 
     /* Forward declarations */
-extern int calmaWriteInitFunc(CellDef *def);
-extern int calmaWritePaintFunc(Tile *tile, calmaOutputStruct *cos);
-extern int calmaMergePaintFunc(Tile *tile, calmaOutputStruct *cos);
+extern int calmaWriteInitFunc(CellDef *def, ClientData cdata);	/* UNUSED */
+extern int calmaWritePaintFunc(Tile *tile, TileType dinfo, calmaOutputStruct *cos);
+extern int calmaMergePaintFunc(Tile *tile, TileType dinfo, calmaOutputStruct *cos);
 extern int calmaWriteUseFunc(CellUse *use, FILE *f);
-extern int calmaPaintLabelFunc(Tile *tile, calmaOutputStruct *cos);
+extern int calmaPaintLabelFunc(Tile *tile, TileType dinfo, calmaOutputStruct *cos);
 extern void calmaWriteContacts(FILE *f);
 extern void calmaDelContacts(void);
-extern void calmaOutFunc(CellDef *def, FILE *f, Rect *cliprect);
+extern void calmaOutFunc(CellDef *def, FILE *f, const Rect *cliprect);
 extern void calmaOutStructName(int type, CellDef *def, FILE *f);
 extern void calmaWriteLabelFunc(Label *lab, int ltype, int type, FILE *f);
 extern void calmaOutHeader(CellDef *rootDef, FILE *f);
@@ -117,8 +124,8 @@ extern void calmaRemoveDegenerate(BoundaryTop *blist);
 #define GDS_PROCESSED	1
 
 #define PUSHTILEC(tp) \
-    if ((tp)->ti_client == (ClientData) GDS_UNPROCESSED) { \
-	(tp)->ti_client = (ClientData) GDS_PENDING; \
+    if (TiGetClient(tp) == GDS_UNPROCESSED) { \
+	TiSetClientINT(tp, GDS_PENDING); \
 	STACKPUSH((ClientData) (tp), SegStack); \
     }
 
@@ -521,7 +528,7 @@ calmaDumpStructure(
 
 	    /* Is view abstract? */
 	    DBPropGet(edef, "LEFview", &isAbstract);
-	    chklibname = (char *)DBPropGet(edef, "GDS_FILE", &isReadOnly);
+	    chklibname = DBPropGetString(edef, "GDS_FILE", &isReadOnly);
 
 	    if (isAbstract && isReadOnly)
 	    {
@@ -731,7 +738,7 @@ calmaFullDump(
      * names in the GDS file do not shadow any names in the database.
      */
 
-    viewopts = (char *)DBPropGet(def, "LEFview", &isAbstract);
+    viewopts = DBPropGetString(def, "LEFview", &isAbstract);
     if ((!isAbstract) || (strcasecmp(viewopts, "no_prefix")))
     {
 	/* Generate a SHORT name for this cell (else it is easy to run into the
@@ -815,9 +822,11 @@ done:
  * ----------------------------------------------------------------------------
  */
 
+/*ARGSUSED*/
 int
 calmaWriteInitFunc(
-    CellDef *def)
+    CellDef *def,
+    ClientData cdata)	/* UNUSED */
 {
     def->cd_client = (ClientData) 0;
     return (0);
@@ -911,7 +920,7 @@ calmaProcessDef(
     DBPropGet(def, "GDS_END", &hasGDSEnd);
     DBPropGet(def, "CIFhier", &needHier);
 
-    filename = (char *)DBPropGet(def, "GDS_FILE", &isReadOnly);
+    filename = DBPropGetString(def, "GDS_FILE", &isReadOnly);
 
     /* When used with "calma addendum true", don't output the read-only	*/
     /* cells.  This makes the library incomplete and dependent on the	*/
@@ -1026,13 +1035,12 @@ calmaProcessDef(
 	}
 	else
 	{
-	    offptr = (char *)DBPropGet(def, "GDS_END", NULL);
-	    sscanf(offptr, "%"DLONG_PREFIX"d", &cval);
+	    cval = DBPropGetDouble(def, "GDS_END", NULL);
 	    cellend = (off_t)cval;
-	    offptr = (char *)DBPropGet(def, "GDS_BEGIN", &oldStyle);
+	    cval = DBPropGetDouble(def, "GDS_BEGIN", &oldStyle);
 	    if (!oldStyle)
 	    {
-		offptr = (char *)DBPropGet(def, "GDS_START", NULL);
+		cval = DBPropGetDouble(def, "GDS_START", NULL);
 
 		/* Write our own header and string name, to ensure	*/
 		/* that the magic cell name and GDS name match.		*/
@@ -1049,7 +1057,6 @@ calmaProcessDef(
 		calmaOutStructName(CALMA_STRNAME, def, outf);
 	    }
 
-	    sscanf(offptr, "%"DLONG_PREFIX"d", &cval);
 	    cellstart = (off_t)cval;
 
 	    /* GDS_START has been defined as the start of data after the cell	*/
@@ -1245,7 +1252,7 @@ void
 calmaOutFunc(
     CellDef *def,	/* Pointer to cell def to be written */
     FILE *f,		/* Open output file */
-    Rect *cliprect)	/* Area to clip to (used for contact cells),
+    const Rect *cliprect)/* Area to clip to (used for contact cells),
 			 * in CIF/GDS coordinates.
 			 */
 {
@@ -1256,7 +1263,7 @@ calmaOutFunc(
     int dbunits;
     calmaOutputStruct cos;
     bool propfound;
-    char *propvalue;
+    PropertyRecord *proprec;
 
     cos.f = f;
     cos.area = (cliprect == &TiPlaneRect) ? NULL : cliprect;
@@ -1316,14 +1323,20 @@ calmaOutFunc(
 
     /* Include any fixed bounding box as part of the area to process,	*/
     /* in case the fixed bounding box is larger than the geometry.	*/
-    propvalue = (char *)DBPropGet(def, "FIXED_BBOX", &propfound);
+    proprec = DBPropGet(def, "FIXED_BBOX", &propfound);
     if (propfound)
     {
 	Rect bbox;
 
-        if (sscanf(propvalue, "%d %d %d %d", &bbox.r_xbot, &bbox.r_ybot,
-                &bbox.r_xtop, &bbox.r_ytop) == 4)
+	if ((proprec->prop_type == PROPERTY_TYPE_DIMENSION) &&
+			(proprec->prop_len == 4))
+	{
+	    bbox.r_xbot = proprec->prop_value.prop_integer[0];
+	    bbox.r_ybot = proprec->prop_value.prop_integer[1];
+	    bbox.r_xtop = proprec->prop_value.prop_integer[2];
+	    bbox.r_ytop = proprec->prop_value.prop_integer[3];
 	    GeoInclude(&bbox, &bigArea);
+	}
     }
 
     CIFErrorDef = def;
@@ -1393,8 +1406,10 @@ calmaOutFunc(
 	    {
 		pllist[i].pl_label = ll->ll_label;
 		pllist[i].pl_port = (unsigned int)ll->ll_attr;
-		freeMagic(ll);
+		free_magic1_t mm1 = freeMagic1_init();
+		freeMagic1(&mm1, ll);
 		ll = ll->ll_next;
+		freeMagic1_end(&mm1);
 		i++;
 	    }	
 
@@ -2415,19 +2430,27 @@ calmaProcessBoundary(
 
 	/* Free the LinkedBoundary list */
 
-	lbref = listtop;
-	while (lbref->lb_next != listtop)
 	{
-	    freeMagic(lbref);
-	    lbref = lbref->lb_next;
+	    free_magic1_t mm1 = freeMagic1_init();
+	    lbref = listtop;
+	    while (lbref->lb_next != listtop)
+	    {
+		freeMagic1(&mm1, lbref);
+		lbref = lbref->lb_next;
+	    }
+	    freeMagic1(&mm1, lbref);
+	    freeMagic1_end(&mm1);
 	}
-	freeMagic(lbref);
     }
 
     /* Free the BoundaryTop list */
 
-    for (bounds = blist; bounds != NULL; bounds = bounds->bt_next)
-	freeMagic(bounds);
+    {
+	free_magic1_t mm1 = freeMagic1_init();
+	for (bounds = blist; bounds != NULL; bounds = bounds->bt_next)
+	    freeMagic1(&mm1, bounds);
+	freeMagic1_end(&mm1);
+    }
 }
 
 /*
@@ -2447,10 +2470,11 @@ calmaProcessBoundary(
 int
 calmaMergePaintFunc(
     Tile *tile,			/* Tile to be written out. */
+    TileType dinfo,		/* Split tile information (unused) */
     calmaOutputStruct *cos)	/* Information needed by algorithm */
 {
     FILE *f = cos->f;
-    Rect *clipArea = cos->area;
+    const Rect *clipArea = cos->area;
     Tile *t, *tp;
     TileType ttype;
     int i, llx, lly, urx, ury, intedges, num_points, split_type;
@@ -2462,7 +2486,7 @@ calmaMergePaintFunc(
     BoundaryTop *bounds = NULL;
 
     /* Quick check for tiles that have already been processed */
-    if (tile->ti_client == (ClientData)GDS_PROCESSED) return 0;
+    if (TiGetClientINT(tile) == GDS_PROCESSED) return 0;
 
     if (SegStack == (Stack *)NULL)
 	SegStack = StackNew(64);
@@ -2471,17 +2495,16 @@ calmaMergePaintFunc(
     while (!StackEmpty(SegStack))
     {
 	t = (Tile *) STACKPOP(SegStack);
-	if (t->ti_client != (ClientData)GDS_PENDING) continue;
-	t->ti_client = (ClientData)GDS_PROCESSED;
+	if (TiGetClientINT(t) != GDS_PENDING) continue;
+	TiSetClientINT(t, GDS_PROCESSED);
 
 	split_type = -1;
 	if (IsSplit(t))
 	{
-	    /* If we use SplitSide, then we need to set it when	the	*/
+	    /* If we use TT_SIDE, then we need to set it when the	*/
 	    /* tile is pushed.  Since these are one-or-zero mask layers	*/
 	    /* I assume it is okay to just check which side is TT_SPACE	*/
 
-	    /* split_type = (SplitSide(t) << 1) | SplitDirection(t); */
 	    split_type = SplitDirection(t);
 	    if (TiGetLeftType(t) == TT_SPACE) split_type |= 2;
 	    num_points = 2;
@@ -2493,8 +2516,10 @@ calmaMergePaintFunc(
 		lb = edge;
 		while (lb->lb_next != edge) lb = lb->lb_next;
 		lb->lb_next = edge->lb_next;
-	 	freeMagic(edge);
+		free_magic1_t mm1 = freeMagic1_init();
+		freeMagic1(&mm1, edge);
 		edge = edge->lb_next;
+		freeMagic1_end(&mm1);
 	    }
 	}
 	else
@@ -2702,7 +2727,9 @@ right_search:
 done_searches:
 	if (intedges == 0)
 	{
-	    calmaWritePaintFunc(t, cos);
+	    calmaWritePaintFunc(t,
+			(split_type & 2) ? (TileType)TT_SIDE : (TileType)0,
+			cos);
 
 	    /* Although calmaWritePaintFunc is called only on isolated	*/
 	    /* tiles, we may have expanded it.  This could use a LOT of	*/
@@ -2713,11 +2740,13 @@ done_searches:
 
 	    if (num_points != 4)
 	    {
+		free_magic1_t mm1 = freeMagic1_init();
 		for (i = 0; i < num_points; i++)
 		{
-		    freeMagic(edge);
+		    freeMagic1(&mm1, edge);
 		    edge = edge->lb_next;
 		}
+		freeMagic1_end(&mm1);
 		edge = NULL;
 	    }
 	    if (!StackEmpty(SegStack))
@@ -2770,10 +2799,11 @@ done_searches:
 int
 calmaWritePaintFunc(
     Tile *tile,			/* Tile to be written out. */
+    TileType dinfo,		/* Split tile information */
     calmaOutputStruct *cos)	/* File for output and clipping area */
 {
     FILE *f = cos->f;
-    Rect *clipArea = cos->area;
+    const Rect *clipArea = cos->area;
     Rect r, r2;
 
     TiToRect(tile, &r);
@@ -2805,7 +2835,7 @@ calmaWritePaintFunc(
 	/* Coordinates */
 	calmaOutRH(36, CALMA_XY, CALMA_I4, f);
 
-	switch ((SplitSide(tile) << 1) | SplitDirection(tile))
+	switch (((dinfo & TT_SIDE) ? 2 : 0) | SplitDirection(tile))
 	{
 	    case 0x0:
 		calmaOutI4(r.r_xbot, f); calmaOutI4(r.r_ybot, f);
@@ -3046,10 +3076,11 @@ calmaWriteLabelFunc(
 int
 calmaPaintLabelFunc(
     Tile *tile,			/* Tile contains area for label. */
+    TileType dinfo,		/* Split tile information (unused) */
     calmaOutputStruct *cos)	/* File for output and clipping area */
 {
     FILE *f = cos->f;
-    Rect *clipArea = cos->area;
+    const Rect *clipArea = cos->area;
     Rect r, r2;
     Point p;
     int len;

calma/CalmaWriteZ.c

@@ -38,10 +38,15 @@ static const char rcsid[] __attribute__ ((unused)) ="$Header: /usr/cvsroot/magic
 #include <ctype.h>
 #include <sys/types.h>
 #include <arpa/inet.h>	/* for htons() */
-#if defined(SYSV) || defined(EMSCRIPTEN)
-#include <time.h>
+#ifdef TIME_WITH_SYS_TIME
+# include <sys/time.h>
+# include <time.h>
 #else
-#include <sys/time.h>
+# ifdef HAVE_SYS_TIME_H
+#  include <sys/time.h>
+# else
+#  include <time.h>
+# endif
 #endif
 
 #include "utils/magic.h"
@@ -49,6 +54,7 @@ static const char rcsid[] __attribute__ ((unused)) ="$Header: /usr/cvsroot/magic
 #include "utils/geometry.h"
 #include "tiles/tile.h"
 #include "utils/utils.h"
+#include "utils/magic_zlib.h"
 #include "utils/hash.h"
 #include "database/database.h"
 #include "database/databaseInt.h"
@@ -90,23 +96,23 @@ extern int calmaPaintLayerNumber;
 extern int calmaPaintLayerType;
 
     /* External functions from CalmaWrite.c */
-extern int calmaWriteInitFunc(CellDef *def);
+extern int calmaWriteInitFunc(CellDef *def, ClientData cdata);	/* UNUSED */
 
 /* Structure used by calmaWritePaintFuncZ() and others */
 
 typedef struct {
    gzFile f;		/* Compressed file stream for output	*/
-   Rect *area;		/* Clipping area, in GDS coordinates	*/
+   const Rect *area;	/* Clipping area, in GDS coordinates	*/
    int type;		/* Layer index				*/
 } calmaOutputStructZ;
 
     /* Forward declarations */
-extern int calmaWritePaintFuncZ(Tile *tile, calmaOutputStructZ *cos);
-extern int calmaMergePaintFuncZ(Tile *tile, calmaOutputStructZ *cos);
+extern int calmaWritePaintFuncZ(Tile *tile, TileType dinfo, calmaOutputStructZ *cos);
+extern int calmaMergePaintFuncZ(Tile *tile, TileType dinfo, calmaOutputStructZ *cos);
 extern int calmaWriteUseFuncZ(CellUse *use, gzFile f);
-extern int calmaPaintLabelFuncZ(Tile *tile, calmaOutputStructZ *cos);
+extern int calmaPaintLabelFuncZ(Tile *tile, TileType dinfo, calmaOutputStructZ *cos);
 extern void calmaWriteContactsZ(gzFile f);
-extern void calmaOutFuncZ(CellDef *def, gzFile f, Rect *cliprect);
+extern void calmaOutFuncZ(CellDef *def, gzFile f, const Rect *cliprect);
 extern void calmaOutStructNameZ(int type, CellDef *def, gzFile f);
 extern void calmaWriteLabelFuncZ(Label *lab, int ltype, int type, gzFile f);
 extern void calmaOutHeaderZ(CellDef *rootDef, gzFile f);
@@ -124,8 +130,8 @@ extern void calmaOutR8Z(double d, gzFile f);
 #define GDS_PROCESSED   1
 
 #define PUSHTILEZ(tp) \
-    if ((tp)->ti_client == (ClientData) GDS_UNPROCESSED) { \
-        (tp)->ti_client = (ClientData) GDS_PENDING; \
+    if (TiGetClient(tp) == GDS_UNPROCESSED) { \
+        TiSetClientINT(tp, GDS_PENDING); \
         STACKPUSH((ClientData) (tp), SegStack); \
     }
 
@@ -502,7 +508,7 @@ calmaDumpStructureZ(
 
 	    /* Is view abstract? */
 	    DBPropGet(edef, "LEFview", &isAbstract);
-	    chklibname = (char *)DBPropGet(edef, "GDS_FILE", &isReadOnly);
+	    chklibname = DBPropGetString(edef, "GDS_FILE", &isReadOnly);
 
 	    if (isAbstract && isReadOnly)
 	    {
@@ -710,7 +716,7 @@ calmaFullDumpZ(
      * names in the GDS file do not shadow any names in the database.
      */
 
-    viewopts = (char *)DBPropGet(def, "LEFview", &isAbstract);
+    viewopts = DBPropGetString(def, "LEFview", &isAbstract);
     if ((!isAbstract) || (strcasecmp(viewopts, "no_prefix")))
     {
 	/* Generate a SHORT name for this cell (else it is easy to run into the
@@ -864,7 +870,7 @@ calmaProcessDefZ(
     DBPropGet(def, "GDS_START", &hasContent);
     DBPropGet(def, "GDS_END", &hasGDSEnd);
     DBPropGet(def, "CIFhier", &needHier);
-    filename = (char *)DBPropGet(def, "GDS_FILE", &isReadOnly);
+    filename = DBPropGetString(def, "GDS_FILE", &isReadOnly);
 
     /* When used with "calma addendum true", don't output the read-only	*/
     /* cells.  This makes the library incomplete and dependent on the	*/
@@ -979,13 +985,12 @@ calmaProcessDefZ(
 	}
 	else
 	{
-	    offptr = (char *)DBPropGet(def, "GDS_END", NULL);
-	    sscanf(offptr, "%"DLONG_PREFIX"d", &cval);
+	    cval = DBPropGetDouble(def, "GDS_END", NULL);
 	    cellend = (z_off_t)cval;
-	    offptr = (char *)DBPropGet(def, "GDS_BEGIN", &oldStyle);
+	    cval = DBPropGetDouble(def, "GDS_BEGIN", &oldStyle);
 	    if (!oldStyle)
 	    {
-		offptr = (char *)DBPropGet(def, "GDS_START", NULL);
+		cval = DBPropGetDouble(def, "GDS_START", NULL);
 
 		/* Write our own header and string name, to ensure	*/
 		/* that the magic cell name and GDS name match.		*/
@@ -1002,7 +1007,6 @@ calmaProcessDefZ(
 		calmaOutStructNameZ(CALMA_STRNAME, def, outf);
 	    }
 
-	    sscanf(offptr, "%"DLONG_PREFIX"d", &cval);
 	    cellstart = (z_off_t)cval;
 
 	    /* GDS_START has been defined as the start of data after the cell	*/
@@ -1169,7 +1173,7 @@ void
 calmaOutFuncZ(
     CellDef *def,	/* Pointer to cell def to be written */
     gzFile f,		/* Open output file */
-    Rect *cliprect)	/* Area to clip to (used for contact cells),
+    const Rect *cliprect)/* Area to clip to (used for contact cells),
 			 * in CIF/GDS coordinates.
 			 */
 {
@@ -1180,6 +1184,7 @@ calmaOutFuncZ(
     int dbunits;
     calmaOutputStructZ cos;
     bool propfound;
+    PropertyRecord *proprec;
     char *propvalue;
     extern int compport(const void *one, const void *two);	/* Forward declaration */
 
@@ -1241,14 +1246,20 @@ calmaOutFuncZ(
 
     /* Include any fixed bounding box as part of the area to process,	*/
     /* in case the fixed bounding box is larger than the geometry.	*/
-    propvalue = (char *)DBPropGet(def, "FIXED_BBOX", &propfound);
+    proprec = DBPropGet(def, "FIXED_BBOX", &propfound);
     if (propfound)
     {
 	Rect bbox;
 
-	if (sscanf(propvalue, "%d %d %d %d", &bbox.r_xbot, &bbox.r_ybot,
-		&bbox.r_xtop, &bbox.r_ytop) == 4)
+	if ((proprec->prop_type == PROPERTY_TYPE_DIMENSION) &&
+		(proprec->prop_len == 4))
+	{
+	    bbox.r_xbot = proprec->prop_value.prop_integer[0];
+	    bbox.r_ybot = proprec->prop_value.prop_integer[1];
+	    bbox.r_xtop = proprec->prop_value.prop_integer[2];
+	    bbox.r_ytop = proprec->prop_value.prop_integer[3];
 	    GeoInclude(&bbox, &bigArea);
+	}
     }
 
     CIFErrorDef = def;
@@ -1318,8 +1329,10 @@ calmaOutFuncZ(
 	    {
 		pllist[i].pl_label = ll->ll_label;
 		pllist[i].pl_port = (unsigned int)ll->ll_attr;
-		freeMagic(ll);
+		free_magic1_t mm1 = freeMagic1_init();
+		freeMagic1(&mm1, ll);
 		ll = ll->ll_next;
+		freeMagic1_end(&mm1);
 		i++;
 	    }
 
@@ -1851,19 +1864,27 @@ calmaProcessBoundaryZ(
 
 	/* Free the LinkedBoundary list */
 
-	lbref = listtop;
-	while (lbref->lb_next != listtop)
 	{
-	    freeMagic(lbref);
-	    lbref = lbref->lb_next;
+	    free_magic1_t mm1 = freeMagic1_init();
+	    lbref = listtop;
+	    while (lbref->lb_next != listtop)
+	    {
+		freeMagic1(&mm1, lbref);
+		lbref = lbref->lb_next;
+	    }
+	    freeMagic1(&mm1, lbref);
+	    freeMagic1_end(&mm1);
 	}
-	freeMagic(lbref);
     }
 
     /* Free the BoundaryTop list */
 
-    for (bounds = blist; bounds != NULL; bounds = bounds->bt_next)
-	freeMagic(bounds);
+    {
+	free_magic1_t mm1 = freeMagic1_init();
+	for (bounds = blist; bounds != NULL; bounds = bounds->bt_next)
+	    freeMagic1(&mm1, bounds);
+	freeMagic1_end(&mm1);
+    }
 }
 
 /*
@@ -1883,10 +1904,11 @@ calmaProcessBoundaryZ(
 int
 calmaMergePaintFuncZ(
     Tile *tile,			/* Tile to be written out. */
+    TileType dinfo,		/* Split tile information (unused) */
     calmaOutputStructZ *cos)	/* Information needed by algorithm */
 {
     gzFile f = cos->f;
-    Rect *clipArea = cos->area;
+    const Rect *clipArea = cos->area;
     Tile *t, *tp;
     TileType ttype;
     int i, llx, lly, urx, ury, intedges, num_points, split_type;
@@ -1898,7 +1920,7 @@ calmaMergePaintFuncZ(
     BoundaryTop *bounds = NULL;
 
     /* Quick check for tiles that have already been processed */
-    if (tile->ti_client == (ClientData)GDS_PROCESSED) return 0;
+    if (TiGetClientINT(tile) == GDS_PROCESSED) return 0;
 
     if (SegStack == (Stack *)NULL)
 	SegStack = StackNew(64);
@@ -1907,17 +1929,16 @@ calmaMergePaintFuncZ(
     while (!StackEmpty(SegStack))
     {
 	t = (Tile *) STACKPOP(SegStack);
-	if (t->ti_client != (ClientData)GDS_PENDING) continue;
-	t->ti_client = (ClientData)GDS_PROCESSED;
+	if (TiGetClientINT(t) != GDS_PENDING) continue;
+	TiSetClientINT(t, GDS_PROCESSED);
 
 	split_type = -1;
 	if (IsSplit(t))
 	{
-	    /* If we use SplitSide, then we need to set it when	the	*/
+	    /* If we use TT_SIDE, then we need to set it when the	*/
 	    /* tile is pushed.  Since these are one-or-zero mask layers	*/
 	    /* I assume it is okay to just check which side is TT_SPACE	*/
 
-	    /* split_type = (SplitSide(t) << 1) | SplitDirection(t); */
 	    split_type = SplitDirection(t);
 	    if (TiGetLeftType(t) == TT_SPACE) split_type |= 2;
 	    num_points = 2;
@@ -1929,8 +1950,10 @@ calmaMergePaintFuncZ(
 		lb = edge;
 		while (lb->lb_next != edge) lb = lb->lb_next;
 		lb->lb_next = edge->lb_next;
-	 	freeMagic(edge);
+		free_magic1_t mm1 = freeMagic1_init();
+		freeMagic1(&mm1, edge);
 		edge = edge->lb_next;
+		freeMagic1_end(&mm1);
 	    }
 	}
 	else
@@ -2138,7 +2161,9 @@ right_search:
 done_searches:
 	if (intedges == 0)
 	{
-	    calmaWritePaintFuncZ(t, cos);
+	    calmaWritePaintFuncZ(t,
+			(split_type & 2) ? (TileType)TT_SIDE : (TileType)0,
+			cos);
 
 	    /* Although calmaWritePaintFunc is called only on isolated	*/
 	    /* tiles, we may have expanded it.  This could use a LOT of	*/
@@ -2149,11 +2174,13 @@ done_searches:
 
 	    if (num_points != 4)
 	    {
+		free_magic1_t mm1 = freeMagic1_init();
 		for (i = 0; i < num_points; i++)
 		{
-		    freeMagic(edge);
+		    freeMagic1(&mm1, edge);
 		    edge = edge->lb_next;
 		}
+		freeMagic1_end(&mm1);
 		edge = NULL;
 	    }
 	    if (!StackEmpty(SegStack))
@@ -2206,10 +2233,11 @@ done_searches:
 int
 calmaWritePaintFuncZ(
     Tile *tile,			/* Tile to be written out. */
+    TileType dinfo,		/* Split tile information */
     calmaOutputStructZ *cos)	/* File for output and clipping area */
 {
     gzFile f = cos->f;
-    Rect *clipArea = cos->area;
+    const Rect *clipArea = cos->area;
     Rect r, r2;
 
     TiToRect(tile, &r);
@@ -2241,7 +2269,7 @@ calmaWritePaintFuncZ(
 	/* Coordinates */
 	calmaOutRHZ(36, CALMA_XY, CALMA_I4, f);
 
-	switch ((SplitSide(tile) << 1) | SplitDirection(tile))
+	switch (((dinfo & TT_SIDE) ? 2 : 0) | SplitDirection(tile))
 	{
 	    case 0x0:
 		calmaOutI4Z(r.r_xbot, f); calmaOutI4Z(r.r_ybot, f);
@@ -2482,10 +2510,11 @@ calmaWriteLabelFuncZ(
 int
 calmaPaintLabelFuncZ(
     Tile *tile,			/* Tile contains area for label. */
+    TileType dinfo,		/* Split tile information (unused) */
     calmaOutputStructZ *cos)	/* File for output and clipping area */
 {
     gzFile f = cos->f;
-    Rect *clipArea = cos->area;
+    const Rect *clipArea = cos->area;
     Rect r, r2;
     Point p;
     int len;

calma/calma.h

@@ -19,8 +19,8 @@
  * rcsid $Header: /usr/cvsroot/magic-8.0/calma/calma.h,v 1.1.1.1 2008/02/03 20:43:50 tim Exp $
  */
 
-#ifndef _CALMA_H
-#define _CALMA_H
+#ifndef _MAGIC__CALMA__CALMA_H
+#define _MAGIC__CALMA__CALMA_H
 
 #include "utils/magic.h"
 
@@ -38,6 +38,7 @@ extern TileTypeBitMask *CalmaMaskHints;
 extern bool CalmaMergeTiles;
 extern bool CalmaFlattenArrays;
 extern bool CalmaNoDRCCheck;
+extern bool CalmaRecordPaths;
 extern bool CalmaFlattenUses;
 extern int  CalmaFlattenLimit;
 extern float CalmaMagScale;
@@ -81,6 +82,8 @@ extern int calmaProcessDefZ(CellDef *def, gzFile outf, bool do_library);
 #endif
 extern bool calmaReadI2Record(int type, int *pvalue);
 extern bool calmaReadI4Record(int type, int *pvalue);
+extern void calmaReadX(Point *p, int iscale);
+extern void calmaReadY(Point *p, int iscale);
 extern void calmaReadPoint(Point *p, int iscale);
 extern bool calmaReadR8(double *pd);
 extern bool calmaReadStampRecord(int type, int *stampptr);
@@ -97,4 +100,4 @@ extern bool CalmaWriteZ(CellDef *rootDef, gzFile f);
 extern bool CalmaGenerateArrayZ(gzFile f, TileType type, int llx, int lly, int pitch, int cols, int rows);
 #endif
 
-#endif /* _CALMA_H */
+#endif /* _MAGIC__CALMA__CALMA_H */

calma/calmaInt.h

@@ -19,8 +19,8 @@
  * rcsid $Header: /usr/cvsroot/magic-8.0/calma/calmaInt.h,v 1.2 2010/06/24 12:37:15 tim Exp $
  */
 
-#ifndef _CALMAINT_H
-#define _CALMAINT_H
+#ifndef _MAGIC__CALMA__CALMAINT_H
+#define _MAGIC__CALMA__CALMAINT_H
 
 #include "utils/magic.h"
 #include "database/database.h"
@@ -274,4 +274,4 @@ extern Plane **cifCurReadPlanes;
 extern HashTable CifCellTable;
 extern Plane *cifEditCellPlanes[];
 
-#endif /* _CALMAINT_H */
+#endif /* _MAGIC__CALMA__CALMAINT_H */

cif/CIFhier.c

@@ -209,52 +209,41 @@ typedef struct _maskHintsData
 {
     Transform *mh_trans;
     CellDef *mh_def;
+    Plane *mh_plane;
 } MaskHintsData;
 
 /*
  * ----------------------------------------------------------------------------
  *
- * cifMaskHints --
+ * cifCopyMaskHintFunc --
  *
- *	Copy a mask hint into a target cell by adding it to the
- *	property list of the target cell.  If the target cell already
- *	has the same mask hint key, then the mask hint value is
- *	appended to the property in the target cell def.
+ *	Callback function used by cifFlatMaskHints.  Transforms a tile
+ *	from the original plane and paints it into the target plane,
+ *	both of which are properties.
  *
- * Returns:
- *	0 to keep the search going.
+ * Results:
+ *	Zero to keep the search going.
  *
  * Side effects:
- *	Modifies properties of the target cell def.
+ *	Paints geometry into the target plane.
  *
  * ----------------------------------------------------------------------------
  */
 
-/* DEPRECATED */
 int
-cifMaskHints(
-    char *name,
-    char *value,
-    CellDef *targetDef)
+cifCopyMaskHintFunc(Tile *tile,
+    TileType dinfo,
+    ClientData cdata)
 {
-    char *propvalue, *newval;
-    bool propfound;
+    MaskHintsData *mhd = (MaskHintsData *)cdata;
+    Rect r, newr;
 
-    if (!strncmp(name, "MASKHINTS_", 10))
-    {
-	/* Check if name exists already in the flattened cell */
-	propvalue = (char *)DBPropGet(targetDef, name, &propfound);
-	if (propfound)
-	{
-	    /* Append value to the property */
-	    newval = mallocMagic(strlen(value) + strlen(propvalue) + 2);
-	    sprintf(newval, "%s %s", propvalue, value);
-	}
-	else
-	    newval = StrDup((char **)NULL, value);
+    TiToRect(tile, &r);
+
+    /* Transform tile area to coordinates of mhd->mh_plane and paint */
+    GeoTransRect(mhd->mh_trans, &r, &newr);
+    DBPaintPlane(mhd->mh_plane, &newr, CIFPaintTable, (PaintUndoInfo *)NULL);
 
-	DBPropPut(targetDef, name, newval);
-    }
     return 0;
 }
 
@@ -264,8 +253,8 @@ cifMaskHints(
  * cifFlatMaskHints --
  *
  *	Copy a mask hint into a flattened cell by transforming it into the
- *	coordinate system of the flattened cell, and adding it to the
- *	property list of the flattened cell.
+ *	coordinate system of the flattened cell, and painting it into the
+ *	property plane of the flattened cell.
  *
  * Returns:
  *	0 to keep the search going.
@@ -279,67 +268,40 @@ cifMaskHints(
 int
 cifFlatMaskHints(
     char *name,
-    char *value,
+    PropertyRecord *proprec,
     MaskHintsData *mhd)
 {
     Rect r, newr;
     char *vptr, *newval, *lastval, *propvalue;
     bool propfound;
-    int lastlen, numvals;
+    int i, lastlen, numvals;
+    PropertyRecord *newproprec, *oldproprec;
+    Plane *plane;
 
     if (!strncmp(name, "MASKHINTS_", 10))
     {
-	newval = (char *)NULL;
-	vptr = value;
-	while (*vptr != '\0')
-	{
-	    numvals = sscanf(vptr, "%d %d %d %d", &r.r_xbot, &r.r_ybot,
-			&r.r_xtop, &r.r_ytop);
-	    if (numvals == 4)
-	    {
-		/* Transform rectangle to top level coordinates */
-		GeoTransRect(mhd->mh_trans, &r, &newr);
-		lastval = newval;
-		lastlen = (lastval) ? strlen(lastval) : 0;
-		newval = mallocMagic(40 + lastlen);
-		if (lastval)
-		    strcpy(newval, lastval);
-		else
-		    *newval = '\0';
-		sprintf(newval + lastlen, "%s%d %d %d %d", (lastval) ? " " : "",
-			newr.r_xbot, newr.r_ybot, newr.r_xtop, newr.r_ytop);
-		if (lastval) freeMagic(lastval);
-
-		/* Parse through the four values and check if there's more */
-		while (*vptr && isspace(*vptr)) vptr++;
-		while (*vptr && !isspace(*vptr)) vptr++;
-		while (*vptr && isspace(*vptr)) vptr++;
-		while (*vptr && !isspace(*vptr)) vptr++;
-		while (*vptr && isspace(*vptr)) vptr++;
-		while (*vptr && !isspace(*vptr)) vptr++;
-		while (*vptr && isspace(*vptr)) vptr++;
-		while (*vptr && !isspace(*vptr)) vptr++;
-		while (*vptr && isspace(*vptr)) vptr++;
-	    }
-	    else
-	    {
-		TxError("MASKHINTS_%s:  Expected 4 values, found only %d\n",
-				name + 10, numvals);
-		break;
-	    }
-	}
-
 	/* Check if name exists already in the flattened cell */
-	propvalue = (char *)DBPropGet(mhd->mh_def, name, &propfound);
+	oldproprec = (PropertyRecord *)DBPropGet(mhd->mh_def, name, &propfound);
 	if (propfound)
 	{
-	    /* Append newval to the property */
-	    lastval = newval;
-	    newval = mallocMagic(strlen(lastval) + strlen(propvalue) + 2);
-	    sprintf(newval, "%s %s", propvalue, lastval);
-	    freeMagic(lastval);
+	    ASSERT(oldproprec->prop_type == PROPERTY_TYPE_PLANE,
+			"cifFlatMaskHints");
+	    plane = oldproprec->prop_value.prop_plane;
 	}
-	DBPropPut(mhd->mh_def, name, newval);
+	else
+	{
+	    newproprec = (PropertyRecord *)mallocMagic(sizeof(PropertyRecord));
+	    newproprec->prop_len = 0; 	/* (unused) */
+	    newproprec->prop_type = PROPERTY_TYPE_PLANE;
+	    plane = DBNewPlane((ClientData)TT_SPACE);
+	    newproprec->prop_value.prop_plane = plane;
+	    DBPropPut(mhd->mh_def, name, newproprec);
+	}
+
+	mhd->mh_plane = plane;
+	DBSrPaintArea((Tile *)NULL, proprec->prop_value.prop_plane,
+			&TiPlaneRect, &CIFSolidBits,
+			cifCopyMaskHintFunc, (ClientData)mhd);
     }
     return 0;
 }
@@ -350,9 +312,10 @@ cifFlatMaskHints(
  * CIFCopyMaskHints --
  *
  *	Callback function to copy mask hints from one cell into another.
+ *	(Occasionally called as a standalone function, not as a callback.)
  * 
  * Results:
- *	None.
+ *	Return 0 to keep the search going.
  *
  * Side effects:
  *	May modify properties in the target cell.
@@ -360,7 +323,7 @@ cifFlatMaskHints(
  * ----------------------------------------------------------------------------
  */
 
-void
+int
 CIFCopyMaskHints(
     SearchContext *scx,
     CellDef *targetDef)
@@ -370,38 +333,9 @@ CIFCopyMaskHints(
     CellDef *sourceDef = scx->scx_use->cu_def;
     mhd.mh_trans = &scx->scx_trans;
     mhd.mh_def = targetDef;
+    mhd.mh_plane = (Plane *)NULL;
 
     DBPropEnum(sourceDef, cifFlatMaskHints, &mhd);
-}
-
-/*
- * ----------------------------------------------------------------------------
- *
- * cifHierCopyMaskHints --
- *
- *	Callback function to copy mask hints from a subcell into a flattened
- *	cell, which is passed in the clientData record.
- * 
- * Results:
- *	Always returns 0 to keep the search alive.
- *
- * Side effects:
- *	May modify properties in the flattened cell.
- *
- * ----------------------------------------------------------------------------
- */
-
-int
-cifHierCopyMaskHints(
-    SearchContext *scx,
-    ClientData clientData)
-{
-    MaskHintsData mhd;
-
-    mhd.mh_trans = &scx->scx_trans;
-    mhd.mh_def = (CellDef *)clientData;
-
-    DBPropEnum(scx->scx_use->cu_def, cifFlatMaskHints, &mhd);
     return 0;
 }
 
@@ -433,15 +367,16 @@ cifHierCopyMaskHints(
 int
 cifHierCopyFunc(
     Tile *tile,			/* Pointer to tile to copy. */
+    TileType dinfo,		/* Split tile information */
     TreeContext *cxp)		/* Describes context of search, including
 				 * transform and client data.
 				 */
 {
-    TileType type = TiGetTypeExact(tile);
+    TileType type = TiGetTypeExact(tile) | dinfo;
     Rect sourceRect, targetRect;
     int pNum;
     CellDef *def = (CellDef *) cxp->tc_filter->tf_arg;
-    int dinfo = 0;
+    TileType newdinfo = 0;
 
     /* Ignore tiles in vendor GDS, unless this is specifically	*/
     /* overridden by the "see-vendor" option.			*/
@@ -457,8 +392,8 @@ cifHierCopyFunc(
 
     if (IsSplit(tile))
     {
-	dinfo = DBTransformDiagonal(type, &cxp->tc_scx->scx_trans);
-	type = (SplitSide(tile)) ? SplitRightType(tile) :
+	newdinfo = DBTransformDiagonal(type, &cxp->tc_scx->scx_trans);
+	type = (dinfo & TT_SIDE) ? SplitRightType(tile) :
 		SplitLeftType(tile);
     }
 
@@ -473,7 +408,7 @@ cifHierCopyFunc(
     {
 	if (DBPaintOnPlane(type, pNum))
 	{
-	    DBNMPaintPlane(def->cd_planes[pNum], dinfo, &targetRect,
+	    DBNMPaintPlane(def->cd_planes[pNum], newdinfo, &targetRect,
 		DBStdPaintTbl(type, pNum), (PaintUndoInfo *) NULL);
 	}
     }
@@ -525,7 +460,7 @@ cifHierCellFunc(
 
     /* Flatten mask hints in the area of interest */
     CIFCopyMaskHints(scx, CIFComponentDef);
-    DBTreeSrCells(&newscx, 0, cifHierCopyMaskHints,
+    DBTreeSrCells(&newscx, 0, CIFCopyMaskHints,
 		(ClientData)CIFComponentDef);
 
     /* Set CIFErrorDef to NULL to ignore errors here... these will
@@ -562,9 +497,11 @@ cifHierCellFunc(
 int
 cifHierErrorFunc(
     Tile *tile,			/* Tile that covers area it shouldn't. */
+    TileType dinfo,		/* Split tile information */
     Rect *checkArea)		/* Intersection of this and tile is error. */
 {
     Rect area;
+    bool side = (dinfo & TT_SIDE) ? TRUE : FALSE;
 
     TiToRect(tile, &area);
 
@@ -572,8 +509,8 @@ cifHierErrorFunc(
      * space bounds the checkArea.
      */
     if (IsSplit(tile))
-	if (((area.r_xbot == checkArea->r_xbot) && !SplitSide(tile)) ||
-		((area.r_xtop == checkArea->r_xtop) && SplitSide(tile)))
+	if (((area.r_xbot == checkArea->r_xbot) && !side) ||
+		((area.r_xtop == checkArea->r_xtop) && side))
 	    return 0;
 
     GeoClip(&area, checkArea);
@@ -604,6 +541,7 @@ cifHierErrorFunc(
 int
 cifHierCheckFunc(
     Tile *tile,			/* Tile containing CIF. */
+    TileType dinfo,		/* Split tile information */
     Plane *plane)		/* Plane to check against and modify. */
 {
     Rect area;
@@ -612,10 +550,10 @@ cifHierCheckFunc(
 
     if (IsSplit(tile))
     {
-        DBSrPaintNMArea((Tile *)NULL, plane, TiGetTypeExact(tile),
+        DBSrPaintNMArea((Tile *)NULL, plane, TiGetTypeExact(tile) | dinfo,
 		&area, &DBSpaceBits, cifHierErrorFunc, (ClientData) &area);
 
-	DBNMPaintPlane(plane, TiGetTypeExact(tile), &area, CIFEraseTable,
+	DBNMPaintPlane(plane, TiGetTypeExact(tile) | dinfo, &area, CIFEraseTable,
 		(PaintUndoInfo *) NULL);
     }
     else
@@ -651,6 +589,7 @@ cifHierCheckFunc(
 int
 cifHierTempCheckFunc(
     Tile *tile,			/* Tile containing CIF. */
+    TileType dinfo,		/* Information about split tiles */
     Plane *plane)		/* Plane to check against and modify. */
 {
     Rect area;
@@ -658,7 +597,7 @@ cifHierTempCheckFunc(
     TiToRect(tile, &area);
 
     if (IsSplit(tile))
-	DBNMPaintPlane(plane, TiGetTypeExact(tile), &area, CIFEraseTable,
+	DBNMPaintPlane(plane, TiGetTypeExact(tile) | dinfo, &area, CIFEraseTable,
 		(PaintUndoInfo *) NULL);
     else
         DBPaintPlane(plane, &area, CIFEraseTable, (PaintUndoInfo *) NULL);
@@ -686,6 +625,7 @@ cifHierTempCheckFunc(
 int
 cifHierPaintFunc(
     Tile *tile,
+    TileType dinfo,		/* Information about split tiles */
     Plane *plane)		/* Plane in which to paint CIF over tile's
 				 * area.
 				 */
@@ -693,9 +633,9 @@ cifHierPaintFunc(
     Rect area;
 
     TiToRect(tile, &area);
-    if (CIFCurStyle->cs_flags & CWF_GROW_SLIVERS) cifGrowSliver(tile, &area);
+    if (CIFCurStyle->cs_flags & CWF_GROW_SLIVERS) cifGrowSliver(tile, dinfo, &area);
     if (IsSplit(tile))
-	DBNMPaintPlane(plane, TiGetTypeExact(tile), &area, CIFPaintTable,
+	DBNMPaintPlane(plane, TiGetTypeExact(tile) | dinfo, &area, CIFPaintTable,
 		(PaintUndoInfo *) NULL);
     else
 	DBPaintPlane(plane, &area, CIFPaintTable, (PaintUndoInfo *) NULL);
@@ -795,8 +735,10 @@ CIFGenSubcells(
 
     /* This routine can take a long time, so use the display
      * timer to force a 5-second progress check (like is done
-     * with extract)
+     * with extract).  Save and restore GrDisplayStatus so that
+     * a headless (DISPLAY_SUSPEND) build isn't left in DISPLAY_IDLE.
      */
+    unsigned char savedDisplayStatus = GrDisplayStatus;
     GrDisplayStatus = DISPLAY_IN_PROGRESS;
     SigSetTimer(5);			/* Print at 5-second intervals */
     cuts = 0;
@@ -848,7 +790,7 @@ CIFGenSubcells(
 		cifHierCopyFunc, (ClientData) CIFTotalDef);
 	    /* Flatten mask hints in the area of interest */
     	    CIFCopyMaskHints(&scx, CIFTotalDef);
-	    DBTreeSrCells(&scx, 0, cifHierCopyMaskHints,
+	    DBTreeSrCells(&scx, 0, CIFCopyMaskHints,
                 	(ClientData)CIFTotalDef);
 
 	    CIFErrorDef = def;
@@ -921,7 +863,7 @@ CIFGenSubcells(
 
     CIFHierTileOps += CIFTileOps - oldTileOps;
 
-    GrDisplayStatus = DISPLAY_IDLE;
+    GrDisplayStatus = savedDisplayStatus;
     SigRemoveTimer();
 
     UndoEnable();
@@ -1026,14 +968,14 @@ cifHierElementFunc(
     (void) DBTreeSrTiles(&scx, &CIFCurStyle->cs_yankLayers, 0,
 	cifHierCopyFunc, (ClientData) CIFTotalDef);
     CIFCopyMaskHints(&scx, CIFTotalDef);
-    DBTreeSrCells(&scx, 0, cifHierCopyMaskHints,
+    DBTreeSrCells(&scx, 0, CIFCopyMaskHints,
                 (ClientData)CIFTotalDef);
 
     DBCellClearDef(CIFComponentDef);
     (void) DBTreeSrTiles(&scx, &CIFCurStyle->cs_yankLayers, 0,
 	cifHierCopyFunc, (ClientData) CIFComponentDef);
     CIFCopyMaskHints(&scx, CIFComponentDef);
-    DBTreeSrCells(&scx, 0, cifHierCopyMaskHints,
+    DBTreeSrCells(&scx, 0, CIFCopyMaskHints,
                 (ClientData)CIFComponentDef);
 
     CIFErrorDef = (CellDef *) NULL;
@@ -1067,6 +1009,7 @@ cifHierElementFunc(
 int
 cifGrowSliver(
     Tile *tile,
+    TileType dinfo,		/* Split tile information, needs to be handled */
     Rect *area)
 {
     int height, width, expand_up, expand_side;
@@ -1127,22 +1070,24 @@ cifGrowSliver(
 
 int
 cifHierPaintArrayFunc(
-    Tile *tile)
+    Tile *tile,
+    TileType dinfo,
+    ClientData clientdata)	/* (unused) */
 {
     Rect area;
     int i, j, xbot, xtop;
 
     TiToRect(tile, &area);
-    if (CIFCurStyle->cs_flags & CWF_GROW_SLIVERS) cifGrowSliver(tile, &area);
+    if (CIFCurStyle->cs_flags & CWF_GROW_SLIVERS) cifGrowSliver(tile, dinfo, &area);
     xbot = area.r_xbot;
     xtop = area.r_xtop;
     for (i=0; i<cifHierYCount; i++)
     {
-	for (j=0; j<cifHierXCount; j++)
+	for (j = 0; j < cifHierXCount; j++)
 	{
-	    DBPaintPlane(cifHierCurPlane, &area, CIFPaintTable,
-		(PaintUndoInfo *) NULL);
-	    CIFTileOps += 1;
+	    DBNMPaintPlane(cifHierCurPlane, TiGetTypeExact(tile) | dinfo,
+			&area, CIFPaintTable, (PaintUndoInfo *) NULL);
+	    CIFTileOps++;
 	    area.r_xbot += cifHierXSpacing;
 	    area.r_xtop += cifHierXSpacing;
 	}

cif/CIFint.h

@@ -19,8 +19,8 @@
  * rcsid "$Header: /usr/cvsroot/magic-8.0/cif/CIFint.h,v 1.3 2008/12/04 17:10:29 tim Exp $"
  */
 
-#ifndef _CIFINT_H
-#define _CIFINT_H
+#ifndef _MAGIC__CIF__CIFINT_H
+#define _MAGIC__CIF__CIFINT_H
 
 #include "database/database.h"
 
@@ -141,9 +141,12 @@ typedef struct cifop
  *			which will be painted into parent cells instead of the
  *			current cell.  This replaces the "fault" method.
  * CIFOP_CLOSE -	Added 11/25/19---close up areas smaller than indicated
+ * CIFOP_MANHATTAN -	Added 3/27/25---remove or fill nonmanhattan areas
  * CIFOP_BRIDGE -	Added 6/11/20---Bridge across catecorner gaps
  * CIFOP_BRIDGELIM -	Added 27/07/20---Bridge across catecorner gaps, but with limiting layers
  * CIFOP_MASKHINTS -	Added 12/14/20---Add geometry from cell properties, if any.
+ * CIFOP_NOTSQUARE -	Added 2/26/26---Keep only geometry which is not square.
+ * CIFOP_TAGGED -	Added 3/11/26---Find geometry attached to the given text label
  */
 
 #define CIFOP_AND	1
@@ -167,9 +170,12 @@ typedef struct cifop
 #define CIFOP_INTERACT	19
 #define CIFOP_COPYUP	20
 #define CIFOP_CLOSE	21
-#define CIFOP_BRIDGE	22
-#define CIFOP_BRIDGELIM 23
-#define CIFOP_MASKHINTS 24
+#define CIFOP_MANHATTAN 22
+#define CIFOP_BRIDGE	23
+#define CIFOP_BRIDGELIM 24
+#define CIFOP_MASKHINTS 25
+#define CIFOP_NOTSQUARE 26
+#define CIFOP_TAGGED    27
 
 /* Definitions of bit fields used in the value of co_client for CIFOP_INTERACT */
 #define CIFOP_INT_NOT	   0x1		/* Inverted sense (not interacting) */
@@ -327,16 +333,15 @@ typedef struct cifstyle
 extern bool CIFNameToMask(char *name, TileTypeBitMask *result, TileTypeBitMask *depend);
 extern void CIFGenSubcells(CellDef *def, Rect *area, Plane **output);
 extern void CIFGenArrays(CellDef *def, Rect *area, Plane **output);
-extern void CIFGen(CellDef *cellDef, CellDef *origDef, Rect *area, Plane **planes, TileTypeBitMask *layers,
+extern void CIFGen(CellDef *cellDef, CellDef *origDef, const Rect *area, Plane **planes, TileTypeBitMask *layers,
                    bool replace, bool genAllPlanes, bool hier, ClientData clientdata);
 extern void CIFClearPlanes(Plane **planes);
-extern Plane *CIFGenLayer(CIFOp *op, Rect *area, CellDef *cellDef, CellDef *origDef, Plane *temps[],
+extern Plane *CIFGenLayer(CIFOp *op, const Rect *area, CellDef *cellDef, CellDef *origDef, Plane *temps[],
                           bool hier, ClientData clientdata);
 extern void CIFInitCells(void);
-extern int cifHierCopyFunc(Tile *tile, TreeContext *cxp);
-extern int cifHierCopyMaskHints(SearchContext *scx, ClientData clientData);
+extern int cifHierCopyFunc(Tile *tile, TileType dinfo, TreeContext *cxp);
 extern void CIFLoadStyle(char *stylename);
-extern void CIFCopyMaskHints(SearchContext *scx, CellDef *targetDef);
+extern int CIFCopyMaskHints(SearchContext *scx, CellDef *targetDef);
 
 /* C99 compat */
 extern void CIFCoverageLayer(CellDef *rootDef, Rect *area, char *layer, bool dolist);
@@ -344,7 +349,7 @@ extern bool CIFWriteFlat(CellDef *rootDef, FILE *f);
 extern void CIFScalePlanes(int scalen, int scaled, Plane **planearray);
 extern void CIFInputRescale(int n, int d);
 extern int CIFScaleCoord(int cifCoord, int snap_type);
-extern int cifGrowSliver(Tile *tile, Rect *area);
+extern int cifGrowSliver(Tile *tile, TileType dinfo, Rect *area);
 extern int cifHierElementFunc(CellUse *use, Transform *transform, int x, int y, Rect *checkArea);
 extern int cifSquareFunc(Rect *area, CIFOp *op, int *rows, int *columns, Rect *cut);
 extern int cifSquareGridFunc(Rect *area, CIFOp *op, int *rows, int *columns, Rect *cut);
@@ -365,6 +370,9 @@ extern CellUse *CIFDummyUse;		/* Used to dummy up a CellUse for a
 					 * def.
 					 */
 
+extern Plane *CIFTotalPlanes[];		/* Exported for diagnostics */
+extern Plane *CIFComponentPlanes[];	/* Exported for diagnostics */
+
 /* Valid values of CIFWarningLevel (see cif.h) */
 
 typedef enum {CIF_WARN_DEFAULT, CIF_WARN_NONE, CIF_WARN_ALIGN,
@@ -394,4 +402,4 @@ extern void CIFError(Rect *area, char *message);
 #define CIF_SOLIDTYPE 1
 extern TileTypeBitMask CIFSolidBits;
 
-#endif /* _CIFINT_H */
+#endif /* _MAGIC__CIF__CIFINT_H */

cif/CIFrdcl.c

@@ -505,6 +505,7 @@ CIFParseStart(void)
 
 int cifCheckPaintFunc(
     Tile *tile,
+    TileType dinfo,
     ClientData clientData)
 {
     return 1;
@@ -515,27 +516,28 @@ int cifCheckPaintFunc(
 int
 cifCopyPaintFunc(
     Tile *tile,
+    TileType dinfo,
     CIFCopyRec *cifCopyRec)
 {
     int pNum;
-    TileType dinfo;
+    TileType newdinfo;
     Rect sourceRect, targetRect;
     Transform *trans = cifCopyRec->trans;
     Plane *plane = cifCopyRec->plane;
 
-    dinfo = TiGetTypeExact(tile);
+    newdinfo = TiGetTypeExact(tile) | dinfo;
 
     if (trans)
     {
         TiToRect(tile, &sourceRect);
         GeoTransRect(trans, &sourceRect, &targetRect);
 	if (IsSplit(tile))
-	    dinfo = DBTransformDiagonal(TiGetTypeExact(tile), trans);
+	    newdinfo = DBTransformDiagonal(TiGetTypeExact(tile) | dinfo, trans);
     }
     else
         TiToRect(tile, &targetRect);
 
-    DBNMPaintPlane(plane, dinfo, &targetRect, CIFPaintTable,
+    DBNMPaintPlane(plane, newdinfo, &targetRect, CIFPaintTable,
                 (PaintUndoInfo *)NULL);
 
     return 0;
@@ -561,6 +563,7 @@ cifCopyPaintFunc(
 int
 cifMaskHintFunc(
     Tile *tile,
+    TileType dinfo,	/* Unused, do not support non-manhattan hints */
     LinkedRect **lrecp)
 {
     Rect r;
@@ -597,8 +600,9 @@ int
 CIFPaintCurrent(
     int filetype)
 {
-    extern int cifMakeBoundaryFunc(Tile *tile, ClientData clientdata);	/* Forward declaration. */
-    extern int cifPaintCurrentFunc(Tile *tile, TileType type);	/* Forward declaration. */
+    /* Forward declarations. */
+    extern int cifMakeBoundaryFunc(Tile *tile, TileType dinfo, ClientData clientdata);
+    extern int cifPaintCurrentFunc(Tile *tile, TileType dinfo, TileType type);
 
     Plane *plane, *swapplane;
     int i;
@@ -609,7 +613,7 @@ CIFPaintCurrent(
 	CIFOp *op;
 
 	plane = CIFGenLayer(cifCurReadStyle->crs_layers[i]->crl_ops,
-	    &TiPlaneRect, (CellDef *)NULL, (CellDef *)NULL,
+	    &TiPlaneRect, cifReadCellDef, cifReadCellDef,
 	    cifCurReadPlanes, FALSE, (ClientData)NULL);
 
 	/* Generate a paint/erase table, then paint from the CIF
@@ -684,6 +688,8 @@ CIFPaintCurrent(
 	    }
 	    else if (op == NULL)
 	    {
+		LinkedRect *lrec = NULL, *lsrch;
+
 		/* Handle boundary layer */
 
 		op = cifCurReadStyle->crs_layers[i]->crl_ops;
@@ -698,6 +704,102 @@ CIFPaintCurrent(
 			(ClientData)NULL) == 1))
 		    DBSrPaintArea((Tile *) NULL, plane, &TiPlaneRect,
 			&CIFSolidBits, cifMakeBoundaryFunc, INT2CD(filetype));
+
+		/* Handle mask-hints input operator */
+
+		op = cifCurReadStyle->crs_layers[i]->crl_ops;
+		while (op)
+		{
+		    if (op->co_opcode == CIFOP_MASKHINTS) break;
+		    op = op->co_next;
+		}
+
+		if (op && (DBSrPaintArea((Tile *)NULL, plane, &TiPlaneRect,
+			&DBAllButSpaceBits, cifCheckPaintFunc,
+			(ClientData)NULL) == 1))
+		{
+		    /* (To do:  remove the linked Rects and paint directly
+		     * into the plane in cifMaskHintFunc())
+		     */
+		    DBSrPaintArea((Tile *) NULL, plane, &TiPlaneRect,
+				&CIFSolidBits, cifMaskHintFunc,
+				(ClientData)&lrec);
+
+		    if (lrec != NULL)
+		    {
+			PropertyRecord *proprec, *proporig;
+			char *propname, *layername;
+			int proplen, i, savescale;
+			bool origfound = FALSE;
+			Plane *plane;
+	
+			layername = (char *)op->co_client;
+		    	propname = (char *)mallocMagic(11 + strlen(layername));
+		    	sprintf(propname, "MASKHINTS_%s", layername);
+	
+			/* If there is already a mask hint plane for this layer,
+			 * then add to it;  otherwise, create a new plane.
+			 */
+			proprec = DBPropGet(cifReadCellDef, layername, &origfound);
+			if (origfound)
+			    plane = proprec->prop_value.prop_plane;
+			else
+			{
+			    proprec = (PropertyRecord *)mallocMagic(
+					sizeof(PropertyRecord));
+			    proprec->prop_type = PROPERTY_TYPE_PLANE;
+			    proprec->prop_len = 0;	/* (unused) */
+			    plane = DBNewPlane((ClientData)TT_SPACE);
+			    proprec->prop_value.prop_plane = plane;
+			    DBPropPut(cifReadCellDef, propname, proprec);
+			}
+
+		    	while (lrec != NULL)
+		    	{
+			    lrec->r_r.r_xtop =
+					CIFScaleCoord(lrec->r_r.r_xtop, COORD_EXACT);
+			    savescale = cifCurReadStyle->crs_scaleFactor;
+			    lrec->r_r.r_ytop =
+					CIFScaleCoord(lrec->r_r.r_ytop, COORD_EXACT);
+			    if (savescale != cifCurReadStyle->crs_scaleFactor)
+			    {
+				lrec->r_r.r_xtop *=
+					(savescale / cifCurReadStyle->crs_scaleFactor);
+				savescale = cifCurReadStyle->crs_scaleFactor;
+			    }
+			    lrec->r_r.r_xbot =
+					CIFScaleCoord(lrec->r_r.r_xbot, COORD_EXACT);
+			    if (savescale != cifCurReadStyle->crs_scaleFactor)
+			    {
+				lrec->r_r.r_xtop *=
+					(savescale / cifCurReadStyle->crs_scaleFactor);
+				lrec->r_r.r_ytop *=
+					(savescale / cifCurReadStyle->crs_scaleFactor);
+				savescale = cifCurReadStyle->crs_scaleFactor;
+			    }
+			    lrec->r_r.r_ybot =
+					CIFScaleCoord(lrec->r_r.r_ybot, COORD_EXACT);
+			    if (savescale != cifCurReadStyle->crs_scaleFactor)
+			    {
+				lrec->r_r.r_xtop *=
+					(savescale / cifCurReadStyle->crs_scaleFactor);
+				lrec->r_r.r_ytop *=
+					(savescale / cifCurReadStyle->crs_scaleFactor);
+				lrec->r_r.r_xbot *=
+					(savescale / cifCurReadStyle->crs_scaleFactor);
+			    }
+
+			    DBPaintPlane(plane, &lrec->r_r, CIFPaintTable,
+					(PaintUndoInfo *)NULL);
+	
+			    free_magic1_t mm1 = freeMagic1_init();
+			    freeMagic1(&mm1, lrec);
+			    lrec = lrec->r_next;
+			    freeMagic1_end(&mm1);
+			}
+		    	freeMagic(propname);
+		    }
+		}
 	    }
 
 	    /* Swap planes */
@@ -786,9 +888,7 @@ CIFPaintCurrent(
 
     	for (i = 0; i < cifNReadLayers; i++)
 	{
-	    LinkedRect *lrec = NULL;
-	    char *propstr = NULL;
-	    char locstr[512];
+	    LinkedRect *lrec = NULL, *lsrch;
 	    Plane *tempp;
 
 	    if (!TTMaskHasType(CalmaMaskHints, i)) continue;
@@ -813,51 +913,55 @@ CIFPaintCurrent(
 			(CellDef *)NULL, CIFPlanes, FALSE, (ClientData)NULL);
 
 	    /* Scan the resulting plane and generate linked Rect structures for
-	     * each shape found.
+	     * each shape found.  (To do:  Remove the linked Rects and paint
+	     * directly into the plane in cifMaskHintFunc(), which is more
+	     * efficient but not hugely so.)
 	     */
 	    DBSrPaintArea((Tile *)NULL, presult, &TiPlaneRect, &CIFSolidBits,
 			cifMaskHintFunc, (ClientData)&lrec);
 
 	    if (lrec != NULL)
 	    {
+		PropertyRecord *proprec;
+		bool propfound;
 		char *propname;
+		Plane *plane;
 
 	    	propname = (char *)mallocMagic(11 + strlen(cifReadLayers[i]));
 	    	sprintf(propname, "MASKHINTS_%s", cifReadLayers[i]);
 
-	    	propstr = (char *)NULL;
-
-	    	/* Turn all linked Rects into a mask-hints property in the
-		 * target cell.
+	    	/* Paint all linked Rects into a mask-hints property plane
+		 * in the target cell.
 		 */
+
+		proprec = DBPropGet(cifReadCellDef, propname, &propfound);
+		if (!propfound)
+		{
+		    proprec = (PropertyRecord *)mallocMagic(sizeof(PropertyRecord));
+		    proprec->prop_type = PROPERTY_TYPE_PLANE;
+		    proprec->prop_len = 0;	/* (unused) */
+		    plane = DBNewPlane((ClientData)TT_SPACE);
+		    proprec->prop_value.prop_plane = plane;
+		    DBPropPut(cifReadCellDef, propname, proprec);
+		}
+		else
+		    plane = proprec->prop_value.prop_plane;
+
 	    	while (lrec != NULL)
 	    	{
-		    char *newstr;
-		    sprintf(locstr, "%d %d %d %d",
-				lrec->r_r.r_xbot / CIFCurStyle->cs_scaleFactor,
-				lrec->r_r.r_ybot / CIFCurStyle->cs_scaleFactor,
-				lrec->r_r.r_xtop / CIFCurStyle->cs_scaleFactor,
-				lrec->r_r.r_ytop / CIFCurStyle->cs_scaleFactor);
-		    if (propstr == NULL)
-		    {
-		    	newstr = (char *)mallocMagic(strlen(locstr) + 1);
-		    	sprintf(newstr, "%s", locstr);
-		    }
-		    else
-		    {
-		    	newstr = (char *)mallocMagic(strlen(locstr)
-					+ strlen(propstr) + 2);
-		    	sprintf(newstr, "%s %s", propstr, locstr);
-		    	freeMagic(propstr);
-		    }
-		    propstr = newstr;
-		    freeMagic(lrec);
+		    lrec->r_r.r_xbot /= CIFCurStyle->cs_scaleFactor;
+		    lrec->r_r.r_ybot /= CIFCurStyle->cs_scaleFactor;
+		    lrec->r_r.r_xtop /= CIFCurStyle->cs_scaleFactor;
+		    lrec->r_r.r_ytop /= CIFCurStyle->cs_scaleFactor;
+
+		    DBPaintPlane(plane, &lrec->r_r, CIFPaintTable,
+				(PaintUndoInfo *)NULL);
+
+		    free_magic1_t mm1 = freeMagic1_init();
+		    freeMagic1(&mm1, lrec);
 		    lrec = lrec->r_next;
-	    	}
-		/* NOTE: propstr is transferred to the CellDef and should
-		 * not be free'd here.
-		 */
-		DBPropPut(cifReadCellDef, propname, propstr);
+		    freeMagic1_end(&mm1);
+		}
 	    	freeMagic(propname);
 	    }
 
@@ -889,12 +993,14 @@ CIFPaintCurrent(
 int
 cifMakeBoundaryFunc(
     Tile *tile,			/* Tile of CIF information. */
+    TileType dinfo,		/* Split tile information (unused) */
     ClientData clientdata)	/* Pass the file type (CIF or CALMA) */
 {
     /* It is assumed that there is one rectangle for the boundary.  */
     /* If there are multiple rectangles defined with the boundary   */
     /* layer, then the last one defines the FIXED_BBOX property.    */
 
+    PropertyRecord *proprec;
     Rect area;
     char propertyvalue[128], *storedvalue;
     int savescale;
@@ -926,19 +1032,24 @@ cifMakeBoundaryFunc(
 
     if (cifReadCellDef->cd_flags & CDFIXEDBBOX)
     {
-	char *propvalue;
+	PropertyRecord *proprec;
 	bool found;
 
 	/* Only flag a warning if the redefined boundary was	*/
 	/* different from the original.				*/
 
-	propvalue = (char *)DBPropGet(cifReadCellDef, "FIXED_BBOX", &found);
+	proprec = DBPropGet(cifReadCellDef, "FIXED_BBOX", &found);
 	if (found)
 	{
 	    Rect bbox;
-	    if (sscanf(propvalue, "%d %d %d %d", &bbox.r_xbot, &bbox.r_ybot,
-		    &bbox.r_xtop, &bbox.r_ytop) == 4)
+	    if ((proprec->prop_type == PROPERTY_TYPE_DIMENSION) &&
+			(proprec->prop_len == 4))
 	    {
+		bbox.r_xbot = proprec->prop_value.prop_integer[0];
+		bbox.r_ybot = proprec->prop_value.prop_integer[1];
+		bbox.r_xtop = proprec->prop_value.prop_integer[2];
+		bbox.r_ytop = proprec->prop_value.prop_integer[3];
+
 		if ((bbox.r_xbot != area.r_xbot) ||
 			(bbox.r_ybot != area.r_ybot) ||
 			(bbox.r_xtop != area.r_xtop) ||
@@ -955,10 +1066,15 @@ cifMakeBoundaryFunc(
 	}
     }
 
-    sprintf(propertyvalue, "%d %d %d %d",
-	    area.r_xbot, area.r_ybot, area.r_xtop, area.r_ytop);
-    storedvalue = StrDup((char **)NULL, propertyvalue);
-    DBPropPut(cifReadCellDef, "FIXED_BBOX", storedvalue);
+    proprec = (PropertyRecord *)mallocMagic(sizeof(PropertyRecord) + 2 * sizeof(int));
+    proprec->prop_type = PROPERTY_TYPE_DIMENSION;
+    proprec->prop_len = 4;
+    proprec->prop_value.prop_integer[0] = area.r_xbot;
+    proprec->prop_value.prop_integer[1] = area.r_ybot;
+    proprec->prop_value.prop_integer[2] = area.r_xtop;
+    proprec->prop_value.prop_integer[3] = area.r_ytop;
+
+    DBPropPut(cifReadCellDef, "FIXED_BBOX", proprec);
     cifReadCellDef->cd_flags |= CDFIXEDBBOX;
     return 0;
 }
@@ -968,6 +1084,7 @@ cifMakeBoundaryFunc(
 int
 cifPaintCurrentFunc(
     Tile *tile,			/* Tile of CIF information. */
+    TileType dinfo,		/* Split tile information */
     TileType type)		/* Magic type to be painted. */
 {
     Rect area;
@@ -1017,7 +1134,7 @@ cifPaintCurrentFunc(
     for (pNum = PL_PAINTBASE; pNum < DBNumPlanes; pNum++)
 	if (DBPaintOnPlane(type, pNum))
 	{
-	    DBNMPaintPlane(cifReadCellDef->cd_planes[pNum], TiGetTypeExact(tile),
+	    DBNMPaintPlane(cifReadCellDef->cd_planes[pNum], TiGetTypeExact(tile) | dinfo,
 		    &area, DBStdPaintTbl(type, pNum), (PaintUndoInfo *) NULL);
 	}
 
@@ -1669,8 +1786,8 @@ CIFReadCellCleanup(
     }
 
     /* Do geometrical processing on the top-level cell. */
+    if (filetype == FILE_CIF) CIFPaintCurrent(filetype);
 
-    CIFPaintCurrent(FILE_CIF);
     DBAdjustLabels(EditCellUse->cu_def, &TiPlaneRect);
     DBReComputeBbox(EditCellUse->cu_def);
     DBWAreaChanged(EditCellUse->cu_def, &EditCellUse->cu_def->cd_bbox,

cif/CIFrdpt.c

@@ -244,40 +244,61 @@ CIFPropRecordPath(
 {
     extern float CIFGetOutputScale(int convert);
     CIFPath *pathp;
-    char *pathstr, *sptr;
-    int components;
-    float x, y, oscale, mult;
+    char *namestr = NULL;
+    int components, i, x, y, mult, pathnum;
+    PropertyRecord *proprec;
+    bool propfound;
 
-    oscale = CIFGetOutputScale(1000);   /* 1000 for conversion to um */
-    if (oscale == 0.0) oscale = 1.0;
-    mult = (iswire == TRUE) ? 0.5 : 1.0;
+    /* If "name" is a property, then append a suffix to it to ensure uniqueness */
+    DBPropGet(def, propname, &propfound);
+    if (propfound)
+    {
+	pathnum = 0;
+	namestr = mallocMagic(strlen(propname) + 10);
+	while (propfound)
+	{
+	    sprintf(namestr, "%s_%d", propname, pathnum);
+	    DBPropGet(def, namestr, &propfound);
+	    pathnum++;
+	}
+    }
 
-    pathp = pathheadp;
-    components = 0;
+    mult = (iswire == TRUE) ? 1 : 0;
 
     /* Count the number of components in the path */
+    pathp = pathheadp;
+    components = 0;
     while (pathp != NULL)
     {
-	pathp = pathp->cifp_next;
 	components++;
+	pathp = pathp->cifp_next;
     }
-    /* Allocate enough space to hold 2 * N points at "infinity" */
-    pathstr = (char *)mallocMagic(components * 40);
+    /* Allocate enough space to hold 2 * N points. */
+    proprec = (PropertyRecord *)mallocMagic(sizeof(PropertyRecord) +
+		((components - 1) * 2) * sizeof(int));
+    proprec->prop_type = PROPERTY_TYPE_DIMENSION;
+    proprec->prop_len = components * 2;
 
     pathp = pathheadp;
-    sptr = pathstr;
+    i = 0;
     while (pathp != NULL)
     {
-	x = (float)pathp->cifp_x * oscale * mult;
-	y = (float)pathp->cifp_y * oscale * mult;
-	sprintf(sptr, "%.3f %.3f ", x, y);
-	sptr = sptr + strlen(sptr);
+	x = pathp->cifp_x >> mult;
+	y = pathp->cifp_y >> mult;
+        
+	proprec->prop_value.prop_integer[i] = x;
+	proprec->prop_value.prop_integer[i + 1] = y;
+
+	i += 2;
 	pathp = pathp->cifp_next;
     }
-
-    /* Reallocate pathstr to be no larger than needed to hold the path contents */
-    StrDup(&pathstr, pathstr);
-    DBPropPut(def, propname, (ClientData)pathstr);
+    if (namestr)
+    {
+	DBPropPut(def, namestr, proprec);
+	freeMagic(namestr);
+    }
+    else
+	DBPropPut(def, propname, proprec);
 }
 
 /*
@@ -338,18 +359,20 @@ CIFPaintWirePath(
     pathp = pathheadp->cifp_next;
     if (pathp != NULL)
     {
+	free_magic1_t mm1 = freeMagic1_init();
 	while (pathp->cifp_next != NULL)
 	{
 	    if (pathp->cifp_next->cifp_x == pathp->cifp_x &&
 			pathp->cifp_next->cifp_y == pathp->cifp_y)
 	    {
 		previousp->cifp_next = pathp->cifp_next;
-		freeMagic(pathp);
+		freeMagic1(&mm1, pathp);
 	    }
 	    else
 		previousp = pathp;
 	    pathp = pathp->cifp_next;
 	}
+	freeMagic1_end(&mm1);
     }
 
     previousp = pathheadp;
@@ -439,8 +462,22 @@ CIFPaintWirePath(
 		/* Wire reverses direction.  Break wire here,	*/
 		/* draw, and start new polygon.			*/
 
-		TxError("Warning: direction reversal in path.\n");
+		/* Check first if last point and current point	*/
+		/* are the same, in which case a different	*/
+		/* message should be issued (and possibly	*/
+		/* should be handled differently?)		*/
 
+		if (previousp && previousp->cifp_x == pathp->cifp_x
+			&& previousp->cifp_y == pathp->cifp_y)
+		{
+		    TxError("Warning: duplicate point in path at (%d, %d).\n",
+				pathp->cifp_x / 2, pathp->cifp_y / 2);
+		}
+		else
+		{
+		    TxError("Warning: direction reversal in path at (%d, %d).\n",
+				pathp->cifp_x / 2, pathp->cifp_y / 2);
+		}
 		phi = theta;
 		if (endcap)
 		{
@@ -451,7 +488,8 @@ CIFPaintWirePath(
 		firstpoint = TRUE;
 	    }
 	    else {
-		TxError("Error: mitre limit exceeded at wire junction.\n");
+		TxError("Error: mitre limit exceeded at wire junction at (%d, %d).\n",
+				pathp->cifp_x, pathp->cifp_y);
 		TxError("Route has been truncated.\n");
 		break;
 	   }
@@ -484,11 +522,13 @@ CIFPaintWirePath(
 	    rectp = CIFPolyToRects(polypath, plane, ptable, ui, FALSE);
 	    CIFFreePath(polypath);
 
+	    free_magic1_t mm1 = freeMagic1_init();
 	    for (; rectp != NULL ; rectp = rectp->r_next)
 	    {
 		DBPaintPlane(plane, &rectp->r_r, ptable, ui);
-		freeMagic((char *) rectp);
+		freeMagic1(&mm1, (char *) rectp);
 	    }
+	    freeMagic1_end(&mm1);
 	    polypath = NULL;
 	}
 	else
@@ -586,11 +626,13 @@ PaintPolygon(
     rectlist = CIFPolyToRects(cifpath, plane, ptable, ui, FALSE);
     CIFFreePath(cifpath);
 
+    free_magic1_t mm1 = freeMagic1_init();
     for (rectp = rectlist; rectp != NULL ; rectp = rectp->r_next)
     {
 	DBPaintPlane(plane, &rectp->r_r, ptable, ui);
-	if (!keep) freeMagic((char *) rectp);
+	if (!keep) freeMagic1(&mm1, (char *) rectp);
     }
+    freeMagic1_end(&mm1);
     return (keep) ? rectlist : (LinkedRect *)NULL;
 }
 
@@ -687,7 +729,8 @@ CIFParseWire(void)
 
     width /= cifReadScale2;
     savescale = cifReadScale1;
-    if (!CIFParsePath(&pathheadp, 2))
+    pathheadp = CIFParsePath(2);
+    if (pathheadp == NULL)
     {
 	CIFReadError("wire, but improper path; ignored.\n");
 	CIFSkipToSemi();
@@ -797,7 +840,8 @@ CIFParsePoly(void)
 	CIFSkipToSemi();
 	return FALSE;
     }
-    if (!CIFParsePath(&pathheadp, 1))
+    pathheadp = CIFParsePath(1);
+    if (pathheadp == NULL)
     {
 	CIFReadError("polygon, but improper path; ignored.\n");
 	CIFSkipToSemi();
@@ -817,11 +861,13 @@ CIFParsePoly(void)
 	CIFSkipToSemi();
 	return FALSE;
     }
+    free_magic1_t mm1 = freeMagic1_init();
     for (; rectp != NULL ; rectp = rectp->r_next)
     {
 	DBPaintPlane(cifReadPlane, &rectp->r_r, CIFPaintTable,
 		(PaintUndoInfo *) NULL);
-	freeMagic((char *) rectp);
+	freeMagic1(&mm1, (char *) rectp);
     }
+    freeMagic1_end(&mm1);
     return TRUE;
 }

cif/CIFrdtech.c

@@ -324,13 +324,20 @@ cifNewReadStyle(void)
     {
 	/* Destroy old style and free all memory allocated to it */
 
-	for (i=0; i<MAXCIFRLAYERS; i+=1)
+	for (i = 0; i < MAXCIFRLAYERS; i++)
 	{
 	    layer = cifCurReadStyle->crs_layers[i];
 	    if (layer != NULL)
 	    {
+		free_magic1_t mm1 = freeMagic1_init();
 		for (op = layer->crl_ops; op != NULL; op = op->co_next)
-		    freeMagic((char *)op);
+		{
+		    if (op->co_opcode == CIFOP_MASKHINTS ||
+				op->co_opcode == CIFOP_TAGGED)
+			freeMagic((char *)op->co_client);
+		    freeMagic1(&mm1, (char *)op);
+		}
+		freeMagic1_end(&mm1);
 		freeMagic((char *)layer);
 	    }
 	}
@@ -408,11 +415,13 @@ CIFReadTechInit(void)
 
     /* forget the list of styles */
 
+    free_magic1_t mm1 = freeMagic1_init();
     for (style = cifReadStyleList; style != NULL; style = style->crs_next)
     {
         freeMagic(style->crs_name);
-        freeMagic(style);
+        freeMagic1(&mm1, style);
     }
+    freeMagic1_end(&mm1);
     cifReadStyleList = NULL;
 }
 
@@ -986,6 +995,12 @@ CIFReadTechLine(
 	newOp->co_opcode = CIFOP_COPYUP;
     else if (strcmp(argv[0], "boundary") == 0)
 	newOp->co_opcode = CIFOP_BOUNDARY;
+    else if (strcmp(argv[0], "not-square") == 0)
+	newOp->co_opcode = CIFOP_NOTSQUARE;
+    else if (strcmp(argv[0], "mask-hints") == 0)
+	newOp->co_opcode = CIFOP_MASKHINTS;
+    else if (strcmp(argv[0], "tagged") == 0)
+	newOp->co_opcode = CIFOP_TAGGED;
     else
     {
 	TechError("Unknown statement \"%s\".\n", argv[0]);
@@ -1012,6 +1027,16 @@ CIFReadTechLine(
 		goto errorReturn;
 	    }
 	    break;
+        case CIFOP_MASKHINTS:
+            if (argc != 2) goto wrongNumArgs;
+            newOp->co_client = (ClientData)StrDup((char **)NULL, argv[1]);
+            break;
+        case CIFOP_TAGGED:
+            if ((argc != 2) && (argc != 3)) goto wrongNumArgs;
+            newOp->co_client = (ClientData)StrDup((char **)NULL, argv[1]);
+	    if (argc == 3)
+		CIFParseReadLayers(argv[2], &newOp->co_cifMask, TRUE);
+            break;
     }
 
     /* Link the new CIFOp onto the list. */
@@ -1095,6 +1120,7 @@ CIFReadTechFinal(void)
  *
  * ----------------------------------------------------------------------------
  */
+
 void
 CIFReadLoadStyle(
     char *stylename)

cif/CIFrdutils.c

@@ -276,8 +276,10 @@ CIFScaleCoord(
 		    PlowAfterTech();
 		    ExtTechScale(1, denom);
 		    WireTechScale(1, denom);
+#ifdef ROUTE_MODULE
 		    MZAfterTech();
 		    IRAfterTech();
+#endif
 #ifdef LEF_MODULE
 		    LefTechScale(1, denom);
 #endif
@@ -649,12 +651,11 @@ CIFParsePoint(
  *	one or more points.
  *
  * Results:
- *	TRUE is returned if the path was parsed successfully,
- *	FALSE otherwise.
+ *	non-NULL CIFPath* the caller takes ownership of
+ *	if the path was parsed successfully, otherwise NULL.
  *
  * Side effects:
- *	Modifies the parameter pathheadpp to point to the path
- *	that is constructed.
+ *	None
  *
  * Corrections:
  *	CIF coordinates are multiplied by 2 to cover the case where
@@ -666,17 +667,16 @@ CIFParsePoint(
  * ----------------------------------------------------------------------------
  */
 
-bool
+CIFPath *
 CIFParsePath(
-    CIFPath **pathheadpp,
     int iscale)
 {
-    CIFPath *pathtailp, *newpathp;
+    CIFPath *pathheadp, *pathtailp, *newpathp;
     bool nonManhattan = FALSE;		/* diagnostic only */
     CIFPath path;
     int savescale;
 
-    *pathheadpp = NULL;
+    pathheadp = NULL;
     pathtailp = NULL;
     path.cifp_next = NULL;
     while (TRUE)
@@ -688,12 +688,12 @@ CIFParsePath(
 	savescale = cifReadScale1;
 	if (!CIFParsePoint(&path.cifp_point, iscale))
 	{
-	    CIFFreePath(*pathheadpp);
-	    return FALSE;
+	    CIFFreePath(pathheadp);
+	    return NULL;
 	}
 	if (savescale != cifReadScale1)
 	{
-	    CIFPath *phead = *pathheadpp;
+	    CIFPath *phead = pathheadp;
 	    int newscale = cifReadScale1 / savescale;
 	    while (phead != NULL)
 	    {
@@ -704,7 +704,7 @@ CIFParsePath(
 	}
 	newpathp = (CIFPath *) mallocMagic((unsigned) (sizeof (CIFPath)));
 	*newpathp = path;
-	if (*pathheadpp)
+	if (pathheadp)
 	{
 	    /*
 	     * Check that this segment is Manhattan.  If not, remember the
@@ -721,10 +721,10 @@ CIFParsePath(
 	    }
 	    pathtailp->cifp_next = newpathp;
 	}
-	else *pathheadpp = newpathp;
+	else pathheadp = newpathp;
 	pathtailp = newpathp;
     }
-    return (*pathheadpp != NULL);
+    return pathheadp;
 }
 
 /*
@@ -1338,11 +1338,13 @@ void
 CIFFreePath(
     CIFPath *path)		/* Path to be freed. */
 {
+    free_magic1_t mm1 = freeMagic1_init();
     while (path != NULL)
     {
-	freeMagic((char *) path);
+	freeMagic1(&mm1, (char *) path);
 	path = path->cifp_next;
     }
+    freeMagic1_end(&mm1);
 }
 
 /*

cif/CIFread.h

@@ -21,8 +21,8 @@
  * rcsid "$Header: /usr/cvsroot/magic-8.0/cif/CIFread.h,v 1.3 2010/08/25 17:33:55 tim Exp $
  */
 
-#ifndef _CIFREAD_H
-#define _CIFREAD_H
+#ifndef _MAGIC__CIF__CIFREAD_H
+#define _MAGIC__CIF__CIFREAD_H
 
 #include "cif/CIFint.h"
 
@@ -166,7 +166,7 @@ extern bool CIFParseUser(void);
 extern bool CIFParseCall(void);
 extern bool CIFParseTransform(Transform *transformp);
 extern bool CIFParseInteger(int *valuep);
-extern bool CIFParsePath(CIFPath **pathheadpp, int iscale);
+extern CIFPath *CIFParsePath(int iscale);
 extern bool CIFParsePoint(Point *pointp, int iscale);
 extern bool CIFParseSInteger(int *valuep);
 extern void CIFSkipToSemi(void);
@@ -221,4 +221,4 @@ extern int cifParseLaChar;
 		? (cifParseLaAvail = FALSE, cifParseLaChar) \
 		: (cifParseLaChar = getc(cifInputFile)))
 
-#endif /* _CIFREAD_H */
+#endif /* _MAGIC__CIF__CIFREAD_H */

cif/CIFsee.c

@@ -78,6 +78,7 @@ typedef struct {
 int
 cifPaintDBFunc(
     Tile *tile,			/* Tile of CIF information. */
+    TileType dinfo,
     PaintLayerData *pld)
 {
     Rect area;
@@ -106,7 +107,7 @@ cifPaintDBFunc(
 	if (DBPaintOnPlane(type, pNum))
 	{
 	    ui.pu_pNum = pNum;
-	    DBNMPaintPlane(paintDef->cd_planes[pNum], TiGetTypeExact(tile),
+	    DBNMPaintPlane(paintDef->cd_planes[pNum], TiGetTypeExact(tile) | dinfo,
 		    &area, DBStdPaintTbl(type, pNum), (PaintUndoInfo *) &ui);
 	}
 
@@ -165,9 +166,9 @@ CIFPaintLayer(
     scx.scx_use = CIFDummyUse;
     scx.scx_trans = GeoIdentityTransform;
     (void) DBTreeSrTiles(&scx, &DBAllButSpaceAndDRCBits, 0,
-	cifHierCopyFunc, (ClientData) CIFComponentDef);
+		cifHierCopyFunc, (ClientData) CIFComponentDef);
     CIFCopyMaskHints(&scx, CIFComponentDef);
-    DBTreeSrCells(&scx, 0, cifHierCopyMaskHints,
+    DBTreeSrCells(&scx, 0, CIFCopyMaskHints,
                 (ClientData)CIFComponentDef);
 
     oldCount = DBWFeedbackCount;
@@ -219,6 +220,7 @@ CIFPaintLayer(
 int
 cifSeeFunc(
     Tile *tile,			/* Tile to be entered as feedback. */
+    TileType dinfo,		/* Split tile information */
     SeeLayerData *sld)		/* Layer and explanation for the feedback. */
 {
     Rect area;
@@ -233,10 +235,10 @@ cifSeeFunc(
 		(float)area.r_ybot / (float)CIFCurStyle->cs_scaleFactor);
     }
 
+    /* (NOTE:  Preserve information about the geometry of a diagonal tile) */
     DBWFeedbackAdd(&area, sld->text, cifSeeDef, CIFCurStyle->cs_scaleFactor,
-	sld->style |
-                (TiGetTypeExact(tile) & (TT_DIAGONAL | TT_DIRECTION | TT_SIDE)));
-        /* (preserve information about the geometry of a diagonal tile) */
+		sld->style | ((TiGetTypeExact(tile) | dinfo) &
+		(TT_DIAGONAL | TT_DIRECTION | TT_SIDE)));
     return 0;
 }
 
@@ -285,9 +287,9 @@ CIFSeeLayer(
     scx.scx_use = CIFDummyUse;
     scx.scx_trans = GeoIdentityTransform;
     (void) DBTreeSrTiles(&scx, &DBAllButSpaceAndDRCBits, 0,
-	cifHierCopyFunc, (ClientData) CIFComponentDef);
+		cifHierCopyFunc, (ClientData) CIFComponentDef);
     CIFCopyMaskHints(&scx, CIFComponentDef);
-    DBTreeSrCells(&scx, 0, cifHierCopyMaskHints,
+    DBTreeSrCells(&scx, 0, CIFCopyMaskHints,
                 (ClientData)CIFComponentDef);
 
     oldCount = DBWFeedbackCount;
@@ -438,9 +440,11 @@ CIFCoverageLayer(
     SearchContext scx;
     TileTypeBitMask mask, depend;
     float fcover;
-    int cifCoverageFunc(Tile *tile, ClientData *arg);
     bool doBox = (area != &rootDef->cd_bbox) ? TRUE : FALSE;
 
+    /* Forward declaration */
+    int cifCoverageFunc(Tile *tile, TileType dinfo, ClientData *arg);
+
     /* Check out the CIF layer name. */
 
     if (!CIFNameToMask(layer, &mask, &depend)) return;
@@ -455,9 +459,9 @@ CIFCoverageLayer(
     scx.scx_use = CIFDummyUse;
     scx.scx_trans = GeoIdentityTransform;
     (void) DBTreeSrTiles(&scx, &DBAllButSpaceAndDRCBits, 0,
-	cifHierCopyFunc, (ClientData) CIFComponentDef);
+		cifHierCopyFunc, (ClientData) CIFComponentDef);
     CIFCopyMaskHints(&scx, CIFComponentDef);
-    DBTreeSrCells(&scx, 0, cifHierCopyMaskHints,
+    DBTreeSrCells(&scx, 0, CIFCopyMaskHints,
                 (ClientData)CIFComponentDef);
 
     CIFGen(CIFComponentDef, rootDef, area, CIFPlanes, &depend, TRUE, TRUE,
@@ -500,10 +504,10 @@ CIFCoverageLayer(
     }
     else
     {
-    	TxPrintf("%s Area = %lld CIF units^2\n", doBox ?  "Cursor Box" :
+    	TxPrintf("%s Area = %"DLONG_PREFIX"d CIF units^2\n", doBox ?  "Cursor Box" :
 		"Cell", btotal);
-    	TxPrintf("Layer Bounding Area = %lld CIF units^2\n", atotal);
-    	TxPrintf("Layer Total Area = %lld CIF units^2\n", cstats.coverage);
+    	TxPrintf("Layer Bounding Area = %"DLONG_PREFIX"d CIF units^2\n", atotal);
+    	TxPrintf("Layer Total Area = %"DLONG_PREFIX"d CIF units^2\n", cstats.coverage);
     	TxPrintf("Coverage in %s = %1.1f%%\n", doBox ? "box" :
 		"cell", 100.0 * fcover);
     }
@@ -512,6 +516,7 @@ CIFCoverageLayer(
 int
 cifCoverageFunc(
     Tile *tile,
+    TileType dinfo,	/* (unused) */
     ClientData *arg)
 {
     coverstats *cstats = (coverstats *)arg;

cif/CIFtech.c

@@ -100,6 +100,7 @@ cifTechFreeStyle(void)
 	    layer = CIFCurStyle->cs_layers[i];
 	    if (layer != NULL)
 	    {
+		free_magic1_t mm1 = freeMagic1_init();
 		for (op = layer->cl_ops; op != NULL; op = op->co_next)
 		{
 		    if (op->co_client != (ClientData)NULL)
@@ -111,6 +112,7 @@ cifTechFreeStyle(void)
 			    case CIFOP_MAXRECT:
 			    case CIFOP_BOUNDARY:
 			    case CIFOP_INTERACT:
+			    case CIFOP_MANHATTAN:
 				/* These options use co_client to hold a single	*/
 				/* integer value, so it is not allocated.	*/
 				break;
@@ -119,8 +121,9 @@ cifTechFreeStyle(void)
 				break;
 			}
 		    }
-		    freeMagic((char *)op);
+		    freeMagic1(&mm1, (char *)op);
 		}
+		freeMagic1_end(&mm1);
 		freeMagic((char *)layer);
 	    }
 	}
@@ -233,7 +236,7 @@ cifParseLayers(
 				*/
 {
     TileTypeBitMask curCifMask, curPaintMask;
-    char curLayer[40], *p, *cp;
+    char curLayer[512], *p, *cp;
     TileType paintType;
     int i;
     bool allResidues;
@@ -245,6 +248,10 @@ cifParseLayers(
     {
 	p = curLayer;
 
+	if (*string == '(')
+	    while ((*string != ')') && (*string != 0))
+		*p++ = *string++;
+
 	if (*string == '*')
 	{
 	    allResidues = TRUE;
@@ -262,7 +269,22 @@ cifParseLayers(
 
 	if (paintMask != NULL)
 	{
-	    paintType = DBTechNameTypes(curLayer, &curPaintMask);
+	    if (*curLayer == '(')
+	    {
+		TileType t;
+
+		/* Layer groups with parentheses can only be paint types,
+		 * and will be parsed accordingly.  Residues will be
+		 * handled within the group.  Set paintType to -3, which
+		 * is flagged and handled below.
+		 */
+		DBTechNoisyNameMask(curLayer, &curPaintMask);
+		paintType = -3;
+		allResidues = FALSE;
+	    }
+	    else
+		paintType = DBTechNameTypes(curLayer, &curPaintMask);
+
 	    if (paintType >= 0) goto okpaint;
 	}
 	else paintType = -2;
@@ -298,7 +320,7 @@ okpaint:
 	    TechError("Ambiguous layer (type) \"%s\".\n", curLayer);
 	    continue;
 	}
-	if (paintType >= 0)
+	if ((paintType >= 0) || (paintType == -3))
 	{
 	    if (paintType == TT_SPACE && spaceOK ==0)
 		TechError("\"Space\" layer not permitted in CIF rules.\n");
@@ -368,11 +390,13 @@ CIFTechInit(void)
 
     /* forget the list of styles */
 
+    free_magic1_t mm1 = freeMagic1_init();
     for (style = CIFStyleList; style != NULL; style = style->cs_next)
     {
 	freeMagic(style->cs_name);
-	freeMagic(style);
+	freeMagic1(&mm1, style);
     }
+    freeMagic1_end(&mm1);
     CIFStyleList = NULL;
 }
 
@@ -793,7 +817,7 @@ CIFTechLine(
 	    else
 	    {
 		l = strlen(CIFCurStyle->cs_name) - strlen(tptr);
-		if (!strcmp(tptr, CIFCurStyle->cs_name + l))
+		if ((l > 0) && !strcmp(tptr, CIFCurStyle->cs_name + l))
 		{
 		    CIFCurStyle->cs_status = TECH_PENDING;
 		    return TRUE;
@@ -1083,6 +1107,8 @@ CIFTechLine(
 	newOp->co_opcode = CIFOP_BBOX;
     else if (strcmp(argv[0], "net") == 0)
 	newOp->co_opcode = CIFOP_NET;
+    else if (strcmp(argv[0], "tagged") == 0)
+	newOp->co_opcode = CIFOP_TAGGED;
     else if (strcmp(argv[0], "maxrect") == 0)
 	newOp->co_opcode = CIFOP_MAXRECT;
     else if (strcmp(argv[0], "boundary") == 0)
@@ -1091,6 +1117,10 @@ CIFTechLine(
 	newOp->co_opcode = CIFOP_MASKHINTS;
     else if (strcmp(argv[0], "close") == 0)
 	newOp->co_opcode = CIFOP_CLOSE;
+    else if (strcmp(argv[0], "orthogonal") == 0)
+	newOp->co_opcode = CIFOP_MANHATTAN;
+    else if (strcmp(argv[0], "not-square") == 0)
+	newOp->co_opcode = CIFOP_NOTSQUARE;
     else if (strcmp(argv[0], "bridge") == 0)
 	newOp->co_opcode = CIFOP_BRIDGE;
     else if (strcmp(argv[0], "bridge-lim") == 0)
@@ -1133,7 +1163,6 @@ CIFTechLine(
 	case CIFOP_GROWMIN:
 	case CIFOP_GROW_G:
 	case CIFOP_SHRINK:
-	case CIFOP_CLOSE:
 	    if (argc != 2) goto wrongNumArgs;
 	    newOp->co_distance = atoi(argv[1]);
 	    if (newOp->co_distance <= 0)
@@ -1143,6 +1172,26 @@ CIFTechLine(
 	    }
 	    break;
 
+	case CIFOP_CLOSE:
+	    /* "close" is like "grow" and "shrink" except that it can have
+	     * no argument, in which case any closed shape of any size
+	     * will be closed (useful for finding enclosed areas).
+	     */
+	    if (argc == 1)
+		newOp->co_distance = 0;
+	    else if (argc != 2)
+		goto wrongNumArgs;
+	    else
+	    {
+		newOp->co_distance = atoi(argv[1]);
+		if (newOp->co_distance <= 0)
+		{
+		    TechError("Grow/shrink distance must be greater than zero.\n");
+		    goto errorReturn;
+		}
+	    }
+	    break;
+
 	case CIFOP_BRIDGE:
 	    if (argc != 3) goto wrongNumArgs;
 	    newOp->co_distance = atoi(argv[1]);
@@ -1310,10 +1359,12 @@ bloatCheck:
 	    bloatDone: break;
 
 	case CIFOP_NET:
-	    if (argc != 3) goto wrongNumArgs;
+	case CIFOP_TAGGED:
+	    if ((argc != 2) && (argc != 3)) goto wrongNumArgs;
 	    newOp->co_client = (ClientData)StrDup((char **)NULL, argv[1]);
-	    cifParseLayers(argv[2], CIFCurStyle, &newOp->co_paintMask,
-		&newOp->co_cifMask, FALSE);
+	    if (argc == 3)
+		cifParseLayers(argv[2], CIFCurStyle, &newOp->co_paintMask,
+			&newOp->co_cifMask, FALSE);
 	    break;
 
 	case CIFOP_MASKHINTS:
@@ -1334,6 +1385,19 @@ bloatCheck:
 		goto wrongNumArgs;
 	    break;
 
+	case CIFOP_MANHATTAN:
+	    if (argc == 2)
+	    {
+		if (!strcmp(argv[1], "fill"))
+		    newOp->co_client = (ClientData)1;
+		else if (strcmp(argv[1], "remove"))
+		    TechError("Orthogonal takes only one optional argument "
+				"\"fill\" or \"remove\" (default).\n");
+	    }
+	    else if (argc != 1)
+		goto wrongNumArgs;
+	    break;
+
 	case CIFOP_BBOX:
 	    if (argc == 2)
 	    {
@@ -1611,12 +1675,12 @@ cifComputeRadii(
 
     for (op = layer->cl_ops; op != NULL; op = op->co_next)
     {
-	/* BBOX, NET, and MASKHINTS operators should never be used	*/
-	/* hierarchically so ignore any grow/shrink operators that	*/
+	/* BBOX, NET, TAGGED, and MASKHINTS operators should never be	*/
+	/* used	hierarchically so ignore any grow/shrink operators that	*/
 	/* come after them.						*/
 
 	if (op->co_opcode == CIFOP_BBOX || op->co_opcode == CIFOP_NET ||
-		    op->co_opcode == CIFOP_MASKHINTS)
+		    op->co_opcode == CIFOP_TAGGED || op->co_opcode == CIFOP_MASKHINTS)
 	    break;
 
 	/* If CIF layers are used, switch to the max of current
@@ -1723,7 +1787,8 @@ cifComputeHalo(
     if (maxGrow > maxShrink)
 	style->cs_radius = 2*maxGrow;
     else style->cs_radius = 2*maxShrink;
-    style->cs_radius /= style->cs_scaleFactor;
+    if (style->cs_scaleFactor > 0)
+	style->cs_radius /= style->cs_scaleFactor;
     style->cs_radius++;
 
     /* TxPrintf("Radius for %s CIF is %d.\n",
@@ -1925,10 +1990,10 @@ CIFTechFinal(void)
 		    }
 		}
 		/* Presence of op->co_opcode in CIFOP_OR indicates a copy */
-		/* of the SquaresData pointer from a following operator	  */
+		/* of the SquaresData pointer from a following operator.  */
 		/* CIFOP_BBOX and CIFOP_MAXRECT uses the co_client field  */
-		/* as a flag field, while CIFOP_NET and CIFOP_MASKHINTS	  */
-		/* uses it for a string.				  */
+		/* as a flag field, while CIFOP_NET, CIFOP_MASKHINTS, and */
+		/* CIFOP_TAGGED use it for a string.			  */
 		else
 		{
 		    switch (op->co_opcode)
@@ -1938,7 +2003,9 @@ CIFTechFinal(void)
 			case CIFOP_MASKHINTS:
 			case CIFOP_BOUNDARY:
 			case CIFOP_MAXRECT:
+			case CIFOP_MANHATTAN:
 			case CIFOP_NET:
+			case CIFOP_TAGGED:
 			    break;
 			case CIFOP_BRIDGELIM:
 			case CIFOP_BRIDGE:
@@ -2472,7 +2539,9 @@ CIFTechOutputScale(
 			case CIFOP_BOUNDARY:
 			case CIFOP_MASKHINTS:
 			case CIFOP_MAXRECT:
+			case CIFOP_MANHATTAN:
 			case CIFOP_NET:
+			case CIFOP_TAGGED:
 			case CIFOP_INTERACT:
 			    break;
 			case CIFOP_BRIDGELIM:
@@ -2588,8 +2657,8 @@ CIFTechOutputScale(
 		    default:
 			/* op->co_opcode in CIFOP_OR is a pointer copy,	*/
 			/* in CIFOP_BBOX and CIFOP_MAXRECT is a	flag,	*/
-			/* and in CIFOP_NET and CIFOP_MASKHINTS is a	*/
-			/* string.					*/
+			/* and in CIFOP_NET, CIFOP_MASKHINTS, and	*/
+			/* CIFOP_TAGGED is a string.			*/
 			break;
 		}
 	    }

cif/CIFwrite.c

@@ -44,10 +44,10 @@ static const char rcsid[] __attribute__ ((unused)) = "$Header: /usr/cvsroot/magi
 #include "textio/textio.h"
 
     /* Forward declarations */
-extern int cifWriteInitFunc(CellDef *def);
+extern int cifWriteInitFunc(CellDef *def, ClientData cdata);	/* UNUSED */
 extern int cifWriteMarkFunc(CellUse *use);
-extern int cifWritePaintFunc(Tile *tile, FILE *f);
-extern int cifWriteLabelFunc(Tile *tile, FILE *f);
+extern int cifWritePaintFunc(Tile *tile, TileType dinfo, FILE *f);
+extern int cifWriteLabelFunc(Tile *tile, TileType dinfo, FILE *f);
 extern int cifWriteUseFunc(CellUse *use, FILE *f);
 extern void cifOutPreamble(FILE *outf, CellDef *cell);
 extern void cifOut(FILE *outf);
@@ -204,9 +204,11 @@ CIFWrite(
  * ----------------------------------------------------------------------------
  */
 
+/*ARGSUSED*/
 int
 cifWriteInitFunc(
-    CellDef *def)
+    CellDef *def,
+    ClientData cdata)	/* UNUSED */
 {
     def->cd_client = (ClientData) 0;
     return (0);
@@ -584,6 +586,7 @@ cifWriteUseFunc(
 int
 cifWriteLabelFunc(
     Tile *tile,		/* Tile to be written out. */
+    TileType dinfo,	/* Split tile information (unused) */
     FILE *f)		/* File in which to write. */
 {
     Rect r;
@@ -643,7 +646,8 @@ cifWriteLabelFunc(
 int
 cifWritePaintFunc(
     Tile *tile,		/* Tile to be written out. */
-    FILE *f)				/* File in which to write. */
+    TileType dinfo,	/* Split tile information */
+    FILE *f)		/* File in which to write. */
 {
     Rect r;
 
@@ -662,7 +666,7 @@ cifWritePaintFunc(
 	Point points[5];
 	int i, np;
 
-	GrClipTriangle(&r, NULL, FALSE, TiGetTypeExact(tile), points, &np);
+	GrClipTriangle(&r, NULL, FALSE, TiGetTypeExact(tile) | dinfo, points, &np);
 
 	/* Write triangle as a CIF polygon */
 

cif/cif.h

@@ -20,8 +20,8 @@
  * rcsid "$Header: /usr/cvsroot/magic-8.0/cif/cif.h,v 1.4 2010/06/24 12:37:15 tim Exp $
  */
 
-#ifndef _CIF_H
-#define _CIF_H
+#ifndef _MAGIC__CIF__CIF_H
+#define _MAGIC__CIF__CIF_H
 
 #include "database/database.h"
 
@@ -95,4 +95,4 @@ extern LinkedRect *PaintPolygon(Point *pointlist, int number, Plane *plane, Pain
 /* C99 compat */
 extern int CIFGetContactSize(TileType type, int *edge, int *spacing, int *border);
 
-#endif /* _CIF_H */
+#endif /* _MAGIC__CIF__CIF_H */

cmwind/CMWmain.c

@@ -217,10 +217,11 @@ CMWdelete(
  * ----------------------------------------------------------------------------
  */
 
+/*ARGSUSED*/
 void
 CMWreposition(
     MagWindow *window,
-    Rect *newScreenArea,
+    Rect *newScreenArea,	/* UNUSED */
     bool final)
 {
     if (final)

cmwind/cmwind.h

@@ -19,8 +19,8 @@
  * rcsid $Header: /usr/cvsroot/magic-8.0/cmwind/cmwind.h,v 1.2 2009/09/10 20:32:51 tim Exp $
  */
 
-#ifndef _CMWIND_H
-#define _CMWIND_H
+#ifndef _MAGIC__CMWIND__CMWIND_H
+#define _MAGIC__CMWIND__CMWIND_H
 
 #include "windows/windows.h"
 #include "textio/txcommands.h"
@@ -81,4 +81,4 @@ extern bool CMWCheckWritten(void);
 extern void CMWinit(void);
 
 
-#endif /* _CMWIND_H */
+#endif /* _MAGIC__CMWIND__CMWIND_H */

commands/CmdAB.c

@@ -81,6 +81,70 @@ CmdAddPath(
     PaAppend(&Path, cmd->tx_argv[1]);
 }
 
+/*
+ * ----------------------------------------------------------------------------
+ *
+ * CmdArchive --
+ *
+ * Save an entire database to a "crash recovery"-type archive file, or
+ * load a database from a "crash recovery"-type archive file.  Option
+ * "writeall" writes everything, including read-only PDK cells, while
+ * "readref" does not dereference and will prefer files found in the
+ * search path over content in the archive.
+ * 
+ *
+ * Usage:
+ *	archive write|writeall|read|readref file
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	Writes a single file with the contents of the entire database,
+ *	or loads the database with multiple cells from the file.
+ *
+ * ----------------------------------------------------------------------------
+ */
+
+void
+CmdArchive(
+    MagWindow *w,
+    TxCommand *cmd)
+{
+    int option = -1;
+    char *filename = NULL;
+    static const char * const cmdArchiveOpt[] = {"write", "writeall",
+		"read", "readref", 0};
+
+    if (cmd->tx_argc != 3)
+	TxError("Usage: %s write|writeall|read|readref filename\n", cmd->tx_argv[0]);
+    else
+    {
+	option = Lookup(cmd->tx_argv[1], cmdArchiveOpt);
+	if (option < 0)
+	{
+	    TxError("Usage: %s write|writeall|read|readref filename\n", cmd->tx_argv[0]);
+	    return;
+	}
+    }
+    filename = cmd->tx_argv[2];
+
+    switch(option) {
+	case 0:			/* write */
+	    DBWriteBackup(filename, TRUE, FALSE);
+	    break;
+	case 1:			/* writeall */
+	    DBWriteBackup(filename, TRUE, TRUE);
+	    break;
+	case 2:			/* read */
+	    DBReadBackup(filename, TRUE, TRUE);
+	    break;
+	case 3:			/* readref */
+	    DBReadBackup(filename, TRUE, FALSE);
+	    break;
+    }
+}
+
 
 /* Linked-list structure for returning information about arrayed cells */
 
@@ -274,14 +338,17 @@ CmdArray(
 	case ARRAY_WIDTH:
 	    if (locargc == 2)
 	    {
+		char *xsepvalue;
 		for (la = lahead; la != NULL; la = la->ar_next)
 		{
+		    xsepvalue = DBWPrintValue(la->arrayInfo.ar_xsep,
+				w, TRUE);
 #ifdef MAGIC_WRAPPER
 		    if (doList)
 		    {
 			tobj = Tcl_NewListObj(0, NULL);
 			Tcl_ListObjAppendElement(magicinterp, tobj,
-				Tcl_NewIntObj(la->arrayInfo.ar_xsep));
+				Tcl_NewStringObj(xsepvalue, -1));
 			Tcl_SetObjResult(magicinterp, tobj);
 		    }
 		    else
@@ -291,7 +358,7 @@ CmdArray(
 			    TxPrintf("Cell use \"%s\":", la->cellUse->cu_id);
 			else
 			    TxPrintf("Cell \"%s\":", la->cellUse->cu_def->cd_name);
-			TxPrintf("x separation %d\n", la->arrayInfo.ar_xsep);
+			TxPrintf("x separation %s\n", xsepvalue);
 #ifdef MAGIC_WRAPPER
 		    }
 #endif
@@ -310,14 +377,17 @@ CmdArray(
 	case ARRAY_HEIGHT:
 	    if (locargc == 2)
 	    {
+		char *ysepvalue;
 		for (la = lahead; la != NULL; la = la->ar_next)
 		{
+		    ysepvalue = DBWPrintValue(la->arrayInfo.ar_ysep,
+				w, FALSE);
 #ifdef MAGIC_WRAPPER
 		    if (doList)
 		    {
 			tobj = Tcl_NewListObj(0, NULL);
 			Tcl_ListObjAppendElement(magicinterp, tobj,
-				Tcl_NewIntObj(la->arrayInfo.ar_ysep));
+				Tcl_NewStringObj(ysepvalue, -1));
 			Tcl_SetObjResult(magicinterp, tobj);
 		    }
 		    else
@@ -327,7 +397,7 @@ CmdArray(
 			    TxPrintf("Cell use \"%s\":", la->cellUse->cu_id);
 			else
 			    TxPrintf("Cell \"%s\":", la->cellUse->cu_def->cd_name);
-			TxPrintf("y separation %d\n", la->arrayInfo.ar_ysep);
+			TxPrintf("y separation %s\n", ysepvalue);
 #ifdef MAGIC_WRAPPER
 		    }
 #endif
@@ -346,16 +416,21 @@ CmdArray(
 	case ARRAY_PITCH:
 	    if (locargc == 2)
 	    {
+		char *xpitch, *ypitch;
 		for (la = lahead; la != NULL; la = la->ar_next)
 		{
+		    xpitch = DBWPrintValue(la->arrayInfo.ar_xsep,
+				w, TRUE);
+		    ypitch = DBWPrintValue(la->arrayInfo.ar_ysep,
+				w, FALSE);
 #ifdef MAGIC_WRAPPER
 		    if (doList)
 		    {
 			tobj = Tcl_NewListObj(0, NULL);
 			Tcl_ListObjAppendElement(magicinterp, tobj,
-				Tcl_NewIntObj(la->arrayInfo.ar_xsep));
+				Tcl_NewStringObj(xpitch, -1));
 			Tcl_ListObjAppendElement(magicinterp, tobj,
-				Tcl_NewIntObj(la->arrayInfo.ar_ysep));
+				Tcl_NewStringObj(ypitch, -1));
 			Tcl_SetObjResult(magicinterp, tobj);
 		    }
 		    else
@@ -365,8 +440,8 @@ CmdArray(
 			    TxPrintf("Cell use \"%s\":", la->cellUse->cu_id);
 			else
 			    TxPrintf("Cell \"%s\":", la->cellUse->cu_def->cd_name);
-			TxPrintf("x separation %d ", la->arrayInfo.ar_xsep);
-			TxPrintf("y separation %d\n", la->arrayInfo.ar_ysep);
+			TxPrintf("x separation %s ", xpitch);
+			TxPrintf("y separation %s\n", ypitch);
 #ifdef MAGIC_WRAPPER
 		    }
 #endif
@@ -386,16 +461,21 @@ CmdArray(
 	case ARRAY_POSITION:
 	    if (locargc == 2)
 	    {
+		char *xpos, *ypos;
 		for (la = lahead; la != NULL; la = la->ar_next)
 		{
+		    xpos = DBWPrintValue(la->cellUse->cu_bbox.r_xbot,
+				w, TRUE);
+		    ypos = DBWPrintValue(la->cellUse->cu_bbox.r_ybot,
+				w, FALSE);
 #ifdef MAGIC_WRAPPER
 		    if (doList)
 		    {
 			tobj = Tcl_NewListObj(0, NULL);
 			Tcl_ListObjAppendElement(magicinterp, tobj,
-				Tcl_NewIntObj(la->cellUse->cu_bbox.r_xbot));
+				Tcl_NewStringObj(xpos, -1));
 			Tcl_ListObjAppendElement(magicinterp, tobj,
-				Tcl_NewIntObj(la->cellUse->cu_bbox.r_ybot));
+				Tcl_NewStringObj(ypos, -1));
 			Tcl_SetObjResult(magicinterp, tobj);
 		    }
 		    else
@@ -405,8 +485,8 @@ CmdArray(
 			    TxPrintf("Cell use \"%s\":", la->cellUse->cu_id);
 			else
 			    TxPrintf("Cell \"%s\":", la->cellUse->cu_def->cd_name);
-			TxPrintf("x=%d ", la->cellUse->cu_bbox.r_xbot);
-			TxPrintf("y=%d\n", la->cellUse->cu_bbox.r_ybot);
+			TxPrintf("x=%s ", xpos);
+			TxPrintf("y=%s\n", ypos);
 #ifdef MAGIC_WRAPPER
 		    }
 #endif
@@ -466,11 +546,15 @@ badusage:
     }
 
 freelist:
-    la = lahead;
-    while (la != NULL)
     {
-	freeMagic((char *)la);
-	la = la->ar_next;
+	la = lahead;
+	while (la != NULL)
+	{
+	    free_magic1_t mm1 = freeMagic1_init();
+	    freeMagic1(&mm1, (char *)la);
+	    la = la->ar_next;
+	    freeMagic1_end(&mm1);
+	}
     }
     return;
 }
@@ -695,8 +779,8 @@ CmdBox(
 	    break;
 	case BOX_EXISTS:
 #ifdef MAGIC_WRAPPER
-	    Tcl_SetResult(magicinterp, ToolGetBox(NULL, NULL) ?  "1" : "0",
-			NULL);
+	    Tcl_SetObjResult(magicinterp,
+			Tcl_NewBooleanObj(ToolGetBox(NULL, NULL) ?  TRUE : FALSE));
 #else
 	    TxPrintf("%s\n", ToolGetBox(NULL, NULL) ? "True" : "False");
 #endif
@@ -806,13 +890,16 @@ CmdBox(
 		TxRebuildCommand(cmd);
 		return;
 	    }
-	    else if (DBWSnapToGrid != DBW_SNAP_USER)
+	    else if (DBWUnits != DBW_UNITS_USER)
 	    {
 		distancex = cmdParseCoord(w, cmd->tx_argv[3], TRUE, FALSE);
 		distancey = distancex;
 	    }
 	    else
 	    {
+		/* For user units, the distance may be different in the X and Y
+		 * directions for a given value.
+		 */
 		switch (direction)
 		{
 		    case GEO_EAST: case GEO_WEST:
@@ -840,15 +927,14 @@ CmdBox(
 	case BOX_WIDTH:
 	    if (argc == 2)
 	    {
+		char *boxvalues;
+		boxvalues = DBWPrintValue(boxptr->r_xtop - boxptr->r_xbot,
+			w, TRUE);
 #ifdef MAGIC_WRAPPER
-		char *boxvalues = (char *)Tcl_Alloc(50);
-		sprintf(boxvalues, "%d",
-			boxptr->r_xtop - boxptr->r_xbot);
-		Tcl_SetResult(magicinterp, boxvalues, TCL_DYNAMIC);
+		Tcl_SetObjResult(magicinterp, Tcl_NewStringObj(boxvalues, -1));
 #else
-		TxPrintf("%s box width is %d\n",
-			(refEdit) ? "Edit" : "Root",
-			boxptr->r_xtop - boxptr->r_xbot);
+		TxPrintf("%s box width is %s\n", (refEdit) ? "Edit" : "Root",
+			boxvalues);
 #endif
 		return;
 	    }
@@ -860,15 +946,14 @@ CmdBox(
 	case BOX_HEIGHT:
 	    if (argc == 2)
 	    {
+		char *boxvalues;
+		boxvalues = DBWPrintValue(boxptr->r_ytop - boxptr->r_ybot,
+			w, FALSE);
 #ifdef MAGIC_WRAPPER
-		char *boxvalues = (char *)Tcl_Alloc(50);
-		sprintf(boxvalues, "%d",
-			boxptr->r_ytop - boxptr->r_ybot);
-		Tcl_SetResult(magicinterp, boxvalues, TCL_DYNAMIC);
+		Tcl_SetObjResult(magicinterp, Tcl_NewStringObj(boxvalues, -1));
 #else
-		TxPrintf("%s box height is %d\n",
-			(refEdit) ? "Edit" : "Root",
-			boxptr->r_ytop - boxptr->r_ybot);
+		TxPrintf("%s box height is %s\n", (refEdit) ? "Edit" : "Root",
+			boxvalues);
 #endif
 		return;
 	    }
@@ -881,16 +966,24 @@ CmdBox(
 	    if (argc == 2)
 	    {
 #ifdef MAGIC_WRAPPER
-		char *boxvalues = (char *)Tcl_Alloc(50);
-		sprintf(boxvalues, "%d %d",
-			boxptr->r_xtop - boxptr->r_xbot,
-			boxptr->r_ytop - boxptr->r_ybot);
-		Tcl_SetResult(magicinterp, boxvalues, TCL_DYNAMIC);
+		Tcl_Obj *tobj;
+#endif
+		char *boxvaluex, *boxvaluey;
+		boxvaluex = DBWPrintValue(boxptr->r_xtop - boxptr->r_xbot,
+			w, TRUE);
+		boxvaluey = DBWPrintValue(boxptr->r_ytop - boxptr->r_ybot,
+			w, FALSE);
+#ifdef MAGIC_WRAPPER
+		tobj = Tcl_NewListObj(0, NULL);
+		Tcl_ListObjAppendElement(magicinterp, tobj,
+			Tcl_NewStringObj(boxvaluex, -1));
+		Tcl_ListObjAppendElement(magicinterp, tobj,
+			Tcl_NewStringObj(boxvaluey, -1));
+		Tcl_SetObjResult(magicinterp, tobj);
 #else
-		TxPrintf("%s box size is %d x %d\n",
+		TxPrintf("%s box size is %s x %s\n",
 			(refEdit) ? "Edit" : "Root",
-			boxptr->r_xtop - boxptr->r_xbot,
-			boxptr->r_ytop - boxptr->r_ybot);
+			boxvaluex, boxvaluey);
 #endif
 		return;
 	    }
@@ -905,14 +998,22 @@ CmdBox(
 	    if (argc == 2)
 	    {
 #ifdef MAGIC_WRAPPER
-		char *boxvalues = (char *)Tcl_Alloc(50);
-		sprintf(boxvalues, "%d %d",
-			boxptr->r_xbot, boxptr->r_ybot);
-		Tcl_SetResult(magicinterp, boxvalues, TCL_DYNAMIC);
+		Tcl_Obj *tobj;
+#endif
+		char *boxvaluex, *boxvaluey;
+		boxvaluex = DBWPrintValue(boxptr->r_xbot, w, TRUE);
+		boxvaluey = DBWPrintValue(boxptr->r_ybot, w, FALSE);
+#ifdef MAGIC_WRAPPER
+		tobj = Tcl_NewListObj(0, NULL);
+		Tcl_ListObjAppendElement(magicinterp, tobj,
+				Tcl_NewStringObj(boxvaluex, -1));
+		Tcl_ListObjAppendElement(magicinterp, tobj,
+				Tcl_NewStringObj(boxvaluey, -1));
+		Tcl_SetObjResult(magicinterp, tobj);
 #else
-		TxPrintf("%s box lower-left corner at (%d, %d)\n",
+		TxPrintf("%s box lower-left corner at (%s, %s)\n",
 			(refEdit) ? "Edit" : "Root",
-			boxptr->r_xbot, boxptr->r_ybot);
+			boxvaluex, boxvaluey);
 #endif
 		return;
 	    }
@@ -944,16 +1045,31 @@ CmdBox(
 	    if (argc == 2)
 	    {
 #ifdef MAGIC_WRAPPER
-		char *boxvalues = (char *)Tcl_Alloc(50);
-		sprintf(boxvalues, "%d %d %d %d",
-			boxptr->r_xbot, boxptr->r_ybot,
-			boxptr->r_xtop, boxptr->r_ytop);
-		Tcl_SetResult(magicinterp, boxvalues, TCL_DYNAMIC);
+		Tcl_Obj *tobj;
+#endif
+		char *boxvaluellx, *boxvaluelly;
+		char *boxvalueurx, *boxvalueury;
+
+		boxvaluellx = DBWPrintValue(boxptr->r_xbot, w, TRUE);
+		boxvaluelly = DBWPrintValue(boxptr->r_ybot, w, FALSE);
+		boxvalueurx = DBWPrintValue(boxptr->r_xtop, w, TRUE);
+		boxvalueury = DBWPrintValue(boxptr->r_ytop, w, FALSE);
+#ifdef MAGIC_WRAPPER
+
+		tobj = Tcl_NewListObj(0, NULL);
+		Tcl_ListObjAppendElement(magicinterp, tobj,
+			Tcl_NewStringObj(boxvaluellx, -1));
+		Tcl_ListObjAppendElement(magicinterp, tobj,
+			Tcl_NewStringObj(boxvaluelly, -1));
+		Tcl_ListObjAppendElement(magicinterp, tobj,
+			Tcl_NewStringObj(boxvalueurx, -1));
+		Tcl_ListObjAppendElement(magicinterp, tobj,
+			Tcl_NewStringObj(boxvalueury, -1));
+		Tcl_SetObjResult(magicinterp, tobj);
 #else
-		TxPrintf("%s box coordinates (%d, %d) to (%d, %d)\n",
+		TxPrintf("%s box coordinates (%s, %s) to (%s, %s)\n",
 			(refEdit) ? "Edit" : "Root",
-			boxptr->r_xbot, boxptr->r_ybot,
-			boxptr->r_xtop, boxptr->r_ytop);
+			boxvaluellx, boxvaluelly, boxvalueurx, boxvalueury);
 #endif
 		return;
 	    }

commands/CmdCD.c

@@ -24,6 +24,7 @@ static const char rcsid[] __attribute__ ((unused)) = "$Header: /usr/cvsroot/magi
 #include <stdlib.h>
 #include <string.h>
 #include <strings.h>
+#include <unistd.h>
 
 #include "tcltk/tclmagic.h"
 #include "utils/magic.h"
@@ -36,6 +37,7 @@ static const char rcsid[] __attribute__ ((unused)) = "$Header: /usr/cvsroot/magi
 #include "utils/main.h"
 #include "commands/commands.h"
 #include "utils/utils.h"
+#include "utils/magic_zlib.h"
 #include "textio/textio.h"
 #include "drc/drc.h"
 #include "graphics/graphics.h"
@@ -115,12 +117,13 @@ bool cmdDumpParseArgs(char *cmdName, MagWindow *w, TxCommand *cmd, CellUse *dumm
 #define CALMA_READ	19
 #define CALMA_READONLY	20
 #define CALMA_RESCALE	21
-#define CALMA_WARNING	22
-#define CALMA_WRITE	23
-#define CALMA_POLYS	24
-#define CALMA_PATHS	25
-#define CALMA_UNDEFINED	26
-#define CALMA_UNIQUE	27
+#define CALMA_SAVEPATHS	22
+#define CALMA_WARNING	23
+#define CALMA_WRITE	24
+#define CALMA_POLYS	25
+#define CALMA_PATHS	26
+#define CALMA_UNDEFINED	27
+#define CALMA_UNIQUE	28
 
 #define CALMA_WARN_HELP CIF_WARN_END	/* undefined by CIF module */
 
@@ -173,6 +176,7 @@ CmdCalma(
 	"		into edit cell",
 	"readonly [yes|no]	set cell as read-only and generate output from GDS file",
 	"rescale [yes|no]	allow or disallow internal grid subdivision",
+	"savepaths [yes|no]	save path centerlines as cell properties",
 	"warning [option]	set warning information level",
 	"write file		output Calma GDS-II format to \"file\"\n"
 	"		for the window's root cell",
@@ -429,7 +433,7 @@ CmdCalma(
 #ifdef MAGIC_WRAPPER
 		Tcl_SetObjResult(magicinterp, Tcl_NewDoubleObj((double)CalmaMagScale));
 #else
-		TxPrintf("Text magnification 1.0 = %g microns.\n");
+		TxPrintf("Text magnification 1.0 = %g microns.\n", (double)CalmaMagScale);
 #endif
 		return;
 	    }
@@ -736,13 +740,34 @@ CmdCalma(
 		CalmaSubcellPolygons = (unsigned char)option;
 	    return;
 
+	case CALMA_SAVEPATHS:
+	    if (cmd->tx_argc == 2)
+	    {
+#ifdef MAGIC_WRAPPER
+		Tcl_SetObjResult(magicinterp, Tcl_NewBooleanObj(CalmaRecordPaths));
+#else
+		TxPrintf("Paths in GDS cells read from input file are%s recorded"
+				" as cell properties.\n",
+			(CalmaRecordPaths) ?  " " : " not");
+#endif
+		return;
+	    }
+	    else if (cmd->tx_argc != 3)
+		goto wrongNumArgs;
+
+	    option = Lookup(cmd->tx_argv[2], cmdCalmaYesNo);
+	    if (option < 0)
+		goto wrongNumArgs;
+	    CalmaRecordPaths = (option < 4) ? FALSE : TRUE;
+	    return;
+
 	case CALMA_NO_DUP:
 	    if (cmd->tx_argc == 2)
 	    {
 #ifdef MAGIC_WRAPPER
 		Tcl_SetObjResult(magicinterp, Tcl_NewBooleanObj(CalmaNoDuplicates));
 #else
-		TxPrintf("Cell defs that exist before reading GDS will not be paresd.\n",
+		TxPrintf("Cell defs that exist before reading GDS will %sbe parsed.\n",
 			(CalmaNoDuplicates) ?  "not " : "");
 #endif
 		return;
@@ -762,7 +787,7 @@ CmdCalma(
 #ifdef MAGIC_WRAPPER
 		Tcl_SetObjResult(magicinterp, Tcl_NewBooleanObj(CalmaUnique));
 #else
-		TxPrintf("Cell defs that exist before reading GDS will be renamed.\n",
+		TxPrintf("Cell defs that exist before reading GDS will %sbe renamed.\n",
 			(CalmaUnique) ?  "not " : "");
 #endif
 		return;
@@ -1298,7 +1323,7 @@ CmdCellname(
 	    if (cellDef == (CellDef *) NULL)
 		TxError("Unknown cell %s\n", cellname);
 	    else
-		CmdDoProperty(cellDef, cmd, 3 + ((dolist) ? 1 : 0));
+		CmdDoProperty(cellDef, w, cmd, 3 + ((dolist) ? 1 : 0));
 	    break;
 
 	case IDX_DELETE:
@@ -2394,8 +2419,10 @@ CmdContact(
     CCStruct ccs;
     Rect area;
     LinkedRect *lr = NULL;
-    int cmdContactFunc(Tile *tile, CCStruct *ccs);	/* Forward declaration */
-    int cmdContactEraseFunc(Tile *tile, LinkedRect **lr);	/* Forward declaration */
+
+    /* Forward declarations */
+    int cmdContactFunc(Tile *tile, TileType dinfo, CCStruct *ccs);
+    int cmdContactEraseFunc(Tile *tile, TileType dinfo, LinkedRect **lr);
 
     windCheckOnlyWindow(&w, DBWclientID);
     if ((w == (MagWindow *) NULL) || (w->w_client != DBWclientID))
@@ -2453,6 +2480,7 @@ CmdContact(
 
 	    rmask = DBResidueMask(type);
 
+	    free_magic1_t mm1 = freeMagic1_init();
 	    while (lr != NULL)
 	    {
     		GeoClip(&lr->r_r, &area);
@@ -2463,9 +2491,10 @@ CmdContact(
 	    	    if (TTMaskHasType(rmask, rtype))
 			DBPaint(EditCellUse->cu_def, &lr->r_r, rtype);
 
-		freeMagic(lr);
+		freeMagic1(&mm1, lr);
 		lr = lr->r_next;
 	    }
+	    freeMagic1_end(&mm1);
 
 	    /* Refresh the layout drawing */
 	    DBWAreaChanged(EditCellUse->cu_def, &area, DBW_ALLWINDOWS, &smask);
@@ -2502,14 +2531,16 @@ CmdContact(
 	DBSrPaintArea((Tile *) NULL, EditCellUse->cu_def->cd_planes[DBPlane(rtype)],
 		&area, &smask, cmdContactFunc, (ClientData) &ccs);
 
+	free_magic1_t mm1 = freeMagic1_init();
 	while (ccs.lhead != NULL)
 	{
 	    TTMaskSetOnlyType(&smask, type);
 	    TTMaskAndMask(&smask, &DBActiveLayerBits);
 	    DBPaintMask(EditCellUse->cu_def, &ccs.lhead->r_r, &smask);
-	    freeMagic(ccs.lhead);
+	    freeMagic1(&mm1, ccs.lhead);
 	    ccs.lhead = ccs.lhead->r_next;
 	}
+	freeMagic1_end(&mm1);
 
 	/* Refresh the layout drawing */
 	DBWAreaChanged(EditCellUse->cu_def, &area, DBW_ALLWINDOWS, &smask);
@@ -2525,11 +2556,14 @@ CmdContact(
 int
 cmdContactFunc(
     Tile *tile,
+    TileType dinfo,
     CCStruct *ccs)
 {
     TileType stype;
     TileTypeBitMask smask;
-    int cmdContactFunc2(Tile *tile, CCStruct *ccs);	/* Forward declaration */
+
+    /* Forward declaration */
+    int cmdContactFunc2(Tile *tile, TileType dinfo, CCStruct *ccs);
 
     TiToRect(tile, &ccs->area);
     GeoClip(&ccs->area, &ccs->clip);
@@ -2539,14 +2573,16 @@ cmdContactFunc(
 	    break;
 
     TTMaskSetOnlyType(&smask, stype);
-    DBSrPaintArea((Tile *) NULL, ccs->rootDef->cd_planes[DBPlane(stype)],
-		&ccs->area, &smask, cmdContactFunc2, (ClientData)ccs);
+    DBSrPaintNMArea((Tile *)NULL, ccs->rootDef->cd_planes[DBPlane(stype)],
+		TiGetTypeExact(tile) | dinfo, &ccs->area, &smask,
+		cmdContactFunc2, (ClientData)ccs);
     return 0;
 }
 
 int
 cmdContactFunc2(
     Tile *tile,
+    TileType dinfo,	/* (unused) */
     CCStruct *ccs)
 {
     LinkedRect *newlr;
@@ -2569,6 +2605,7 @@ cmdContactFunc2(
 int
 cmdContactEraseFunc(
     Tile *tile,
+    TileType dinfo,	/* (unused) */
     LinkedRect **lr)
 {
     LinkedRect *newlr;
@@ -2822,14 +2859,15 @@ CmdCorner(
     TileTypeBitMask maskBits;
     Rect editBox;
     SearchContext scx;
-    extern int cmdCornerFunc(Tile *tile, TreeContext *cxp);
     bool hasErr = FALSE;
     int locargc = cmd->tx_argc;
-
-    extern int cmdBevelFunc(Tile *tile, TreeContext *cxp);
     bool dobevel = FALSE;
     NMCornerPath cmdPathList;
 
+    /* Forward declarations */
+    extern int cmdCornerFunc(Tile *tile, TileType dinfo, TreeContext *cxp);
+    extern int cmdBevelFunc(Tile *tile, TileType dinfo, TreeContext *cxp);
+
     if (cmd->tx_argc < 3 || cmd->tx_argc > 5)
     {
 	TxError("Usage: %s direction1 direction2 [layers]\n",
@@ -2950,14 +2988,22 @@ CmdCorner(
 
 	    rectp = CIFPolyToRects(cmdPathList.pathlist->pathhead, plane,
 			resultTbl, &ui, FALSE);
-	    for (; rectp != NULL; rectp = rectp->r_next)
 	    {
-		DBPaintPlane(plane, &rectp->r_r, resultTbl, &ui);
-		freeMagic((char *)rectp);
+		free_magic1_t mm1 = freeMagic1_init();
+		for (; rectp != NULL; rectp = rectp->r_next)
+		{
+		    DBPaintPlane(plane, &rectp->r_r, resultTbl, &ui);
+		    freeMagic1(&mm1, (char *)rectp);
+		}
+		freeMagic1_end(&mm1);
 	    }
 	    CIFFreePath(cmdPathList.pathlist->pathhead);
-	    freeMagic((char *)cmdPathList.pathlist);
-	    cmdPathList.pathlist = cmdPathList.pathlist->cpl_next;
+	    {
+		free_magic1_t mm1 = freeMagic1_init();
+		freeMagic1(&mm1, (char *)cmdPathList.pathlist);
+		cmdPathList.pathlist = cmdPathList.pathlist->cpl_next;
+		freeMagic1_end(&mm1);
+	    }
 	}
     }
     else
@@ -2975,14 +3021,16 @@ CmdCorner(
 	/* Now that we've got all the material, scan over the list
 	 * painting the material and freeing up the entries on the list.
 	 */
+	free_magic1_t mm1 = freeMagic1_init();
 	while (cmdCornerList != NULL)
 	{
 	    DBPaint(EditCellUse->cu_def, &cmdCornerList->cca_area,
 			cmdCornerList->cca_type);
-	    freeMagic((char *) cmdCornerList);
+	    freeMagic1(&mm1, (char *) cmdCornerList);
 	    cmdCornerList = cmdCornerList->cca_next;
 	}
-    }
+	freeMagic1_end(&mm1);
+}
 
     SelectClear();
     DBAdjustLabels(EditCellUse->cu_def, &editBox);
@@ -3014,6 +3062,7 @@ CmdCorner(
 int
 cmdCornerFunc(
     Tile *tile,			/* Tile to fill with. */
+    TileType dinfo,		/* Split tile information (unused) */
     TreeContext *cxp)		/* Describes state of search. */
 {
     Rect r1, r2, r3;
@@ -3180,6 +3229,7 @@ AddNewPoint(
 int
 cmdBevelFunc(
     Tile *tile,			/* Tile to fill with. */
+    TileType dinfo,		/* Split tile information (unused) */
     TreeContext *cxp)		/* Describes state of search. */
 {
     Rect r1, r2, r3;
@@ -3641,8 +3691,10 @@ cmdBevelFunc(
     GeoClip(&r3, &cmdCornerRootBox);
     if (GEO_RECTNULL(&r2) || GEO_RECTNULL(&r3))
     {
+	free_magic1_t mm1 = freeMagic1_init();
 	for (pptr = pathhead; pptr != NULL; pptr = pptr->cifp_next)
-	    freeMagic((char *)pptr);
+	    freeMagic1(&mm1, (char *)pptr);
+	freeMagic1_end(&mm1);
 	return 0;
     }
 
@@ -3676,7 +3728,7 @@ cmdBevelFunc(
  * Save cells to or recover cells from a crash backup file
  *
  * Usage:
- *	crash save|recover [file]
+ *	crash save|recover|archive|read [file]
  *
  * Results:
  *	None.
@@ -3711,7 +3763,7 @@ CmdCrash(
 
     switch(option) {
 	case 0:			/* save */
-	    DBWriteBackup(filename);
+	    DBWriteBackup(filename, FALSE, FALSE);
 	    break;
 	case 1:			/* recover */
 	    DBFileRecovery(filename);
@@ -4152,6 +4204,7 @@ CmdDrc(
 
 	    rootUse = (CellUse *) window->w_surfaceID;
 	    dcl = DRCCount(rootUse, &rootArea, doforall);
+	    free_magic1_t mm1 = freeMagic1_init();
 	    while (dcl != NULL)
 	    {
 		if (count_total >= 0)
@@ -4181,9 +4234,10 @@ CmdDrc(
 		    }
 #endif
 		}
-		freeMagic((char *)dcl);
+		freeMagic1(&mm1, (char *)dcl);
 		dcl = dcl->dcl_next;
 	    }
+	    freeMagic1_end(&mm1);
 
 #ifdef MAGIC_WRAPPER
 	    if ((count_total >= 0) || (!dolist))
@@ -4306,6 +4360,8 @@ CmdDrc(
 #endif
 		    TxPrintf("Error area #%d:\n", result);
 		    if (DRCWhy(dolist, rootUse, &area, findonly)) break;
+		    /* Check for interrupt or this will go into an infinite loop */
+		    else if (SigInterruptPending) break;
 		    drc_nth++;
 		}
 		else if (result < 0)
@@ -4332,12 +4388,14 @@ CmdDrc(
 	    }
 	    if (findonly)
 	    {
+		free_magic1_t mm1 = freeMagic1_init();
 		/* Delete temporary rules */
 		while (DRCIgnoreRules != NULL)
 		{
-		    freeMagic(DRCIgnoreRules);
+		    freeMagic1(&mm1, DRCIgnoreRules);
 		    DRCIgnoreRules = DRCIgnoreRules->li_next;
 		}
+		freeMagic1_end(&mm1);
 		/* Replace temporary set of rules */
 		DRCIgnoreRules = DRCSaveRules;
 	    }
@@ -4420,8 +4478,10 @@ CmdDrc(
 	    {
 		while (DRCIgnoreRules != NULL)
 		{
-		    freeMagic(DRCIgnoreRules);
+		    free_magic1_t mm1 = freeMagic1_init();
+		    freeMagic1(&mm1, DRCIgnoreRules);
 		    DRCIgnoreRules = DRCIgnoreRules->li_next;
+		    freeMagic1_end(&mm1);
 		}
 	    }
 	    else
@@ -4477,6 +4537,7 @@ CmdDrc(
 	    {
 		DRCPrintRulesTable (stdout);
 	    }
+	    else
 	    {
 	        FILE *fp = fopen (argv[2], "w");
 	        if (fp == NULL)
@@ -4558,6 +4619,7 @@ CmdDrc(
 int
 cmdDropPaintCell(
     Tile *tile,
+    TileType dinfo,
     TreeContext *cxp)
 {
     CellDef *cellDef = cxp->tc_scx->scx_use->cu_def;
@@ -4566,7 +4628,7 @@ cmdDropPaintCell(
     TileType type;
     Rect area;
 
-    if (SplitSide(tile))
+    if (dinfo & TT_SIDE)
         type = SplitRightType(tile);
     else
         type = SplitLeftType(tile);
@@ -4599,6 +4661,7 @@ cmdDropPaintCell(
 int
 cmdDropFunc(
     Tile *tile,
+    TileType dinfo,
     ClientData clientData)
 {
     TileTypeBitMask tMask, *lMask = (TileTypeBitMask *)clientData;
@@ -4609,7 +4672,7 @@ cmdDropFunc(
     scx.scx_use = EditCellUse;
     scx.scx_trans = GeoIdentityTransform;
 
-    if (SplitSide(tile))
+    if (dinfo & TT_SIDE)
 	type = SplitRightType(tile);
     else
 	type = SplitLeftType(tile);
@@ -4762,9 +4825,10 @@ CmdDrop(
  * Usage:
  *	dump cellName [child refPointChild] [parent refPointParent]
  *
- * where the refPoints are either a label name, e.g., SOCKET_A, or an x-y
- * pair of integers, e.g., 100 200.  The words "child" and "parent" are
- * keywords, and may be abbreviated.
+ * where the refPoints are either "label" and a label name, e.g.,
+ * "label SOCKET_A", a corner position, e.g., "ur", or an x-y pair of
+ * coordinates, e.g., "100 200", or "1um 5um".  The words "child",
+ * "parent", and "label" are keywords, and may be abbreviated.
  *
  * Results:
  *      None.
@@ -4950,15 +5014,20 @@ cmdDumpParseArgs(
     bbox = def->cd_bbox;
     if (def->cd_flags & CDFIXEDBBOX)
     {
-	char *propvalue;
+	PropertyRecord *proprec;
 	bool found;
 
-	propvalue = (char *)DBPropGet(def, "FIXED_BBOX", &found);
+	proprec = DBPropGet(def, "FIXED_BBOX", &found);
 	if (found)
 	{
-	    if (sscanf(propvalue, "%d %d %d %d", &bbox.r_xbot, &bbox.r_ybot,
-		    &bbox.r_xtop, &bbox.r_ytop) != 4)
-		bbox = def->cd_bbox;
+	    if ((proprec->prop_type == PROPERTY_TYPE_DIMENSION) &&
+			(proprec->prop_len == 4))
+	    {
+		bbox.r_xbot = proprec->prop_value.prop_integer[0];
+		bbox.r_ybot = proprec->prop_value.prop_integer[1];
+		bbox.r_xtop = proprec->prop_value.prop_integer[2];
+		bbox.r_ytop = proprec->prop_value.prop_integer[3];
+	    }
 	}
     }
 
@@ -4970,18 +5039,40 @@ cmdDumpParseArgs(
      * points weren't provided.  (Lower-left of the box tool is interpreted
      * in root coordinates).
      */
-	// getcell cellname child 0 0 parent ll v 0 0
+
+    /*
+     * Examples:  getcell cellname v child 0 0 parent ll
+     *		  getcell cellname child 0 0 parent 1um 1um
+     *		  getcell cellname child 0 0
+     *		  getcell cellname 90v child label VDD
+     * etc.
+     */
+
     av = &cmd->tx_argv[2];
     ac = cmd->tx_argc - 2;
     hasChild = hasRoot = hasTrans = FALSE;
     while (ac > 0)
     {
-	static const char * const kwdNames[] = { "child", "parent", "0", "90", "180", "270",
-					    "v", "0v", "90v", "180v", "270v",
-					    "h", "0h", "90h", "180h", "270h", 0 };
-	static const char * const refPointNames[] = { "ll", "lr", "ul", "ur", 0 };
+	static const char * const kwdNames[] = { "child", "parent",
+					"0", "90", "180", "270",
+					"v", "0v", "90v", "180v", "270v",
+					"h", "0h", "90h", "180h", "270h", 0 };
+	typedef enum {
+		IDX_CHILD, IDX_PARENT,
+		IDX_ZERO, IDX_90, IDX_180, IDX_270,
+		IDX_VERT, IDX_ZERO_VERT, IDX_90_VERT, IDX_180_VERT, IDX_270_VERT,
+		IDX_HORZ, IDX_ZERO_HORZ, IDX_90_HORZ, IDX_180_HORZ, IDX_270_HORZ
+	} optionType;
+
+	static const char * const refPointNames[] = {
+			"ll", "lr", "ul", "ur", "label", 0 };
+	typedef enum {
+		IDX_LL, IDX_LR, IDX_UL, IDX_UR, IDX_LABEL
+	} refPointType;
+
 	Label *lab;
-	int n,p;
+	int n, p;
+	Point locp;
 
 	n = Lookup(av[0], kwdNames);
 	if (n < 0)
@@ -4991,130 +5082,143 @@ cmdDumpParseArgs(
 	}
 	switch (n)
 	{
-	    case  0:	/* Child */
+	    case  IDX_CHILD:	/* "child" */
 		if (ac < 2)
 		{
 		    TxError("Keyword must be followed by a reference point\n");
 		    goto usage;
 	        }
-		//else if (ac == 3) # error case: getcell cellname child 0 0 parent ll -> (ac > 3) -> read 0 as label 
-		else if (ac >= 3 && StrIsInt(av[1]) && StrIsInt(av[2]))
-		{
-		    childPoint.p_x = cmdParseCoord(w, av[1], TRUE, TRUE);
-		    childPoint.p_y = cmdParseCoord(w, av[2], TRUE, FALSE);
-		    av += 3;
-		    ac -= 3;
-		}
 		else
 		{
 		    p = Lookup(av[1], refPointNames);
-		    if (p == 0) /* lower left */
+		    if (p == IDX_LL) /* lower left */
 		    {
 			childPoint.p_x = bbox.r_ll.p_x;
 			childPoint.p_y = bbox.r_ll.p_y;
 		    }
-		    else if (p == 1) /* lower right */
+		    else if (p == IDX_LR) /* lower right */
 		    {
 			childPoint.p_x = bbox.r_ur.p_x;
 			childPoint.p_y = bbox.r_ll.p_y;
 		    }
-		    else if (p == 2) /* upper left */
+		    else if (p == IDX_UL) /* upper left */
 		    {
 			childPoint.p_x = bbox.r_ll.p_x;
 			childPoint.p_y = bbox.r_ur.p_y;
 		    }
-		    else if (p == 3) /* upper right */
+		    else if (p == IDX_UR) /* upper right */
 		    {
 			childPoint.p_x = bbox.r_ur.p_x;
 			childPoint.p_y = bbox.r_ur.p_y;
 		    }
-		    else
+		    else if ((p == IDX_LABEL) && (ac >= 3)) /* label */
 		    {
 			childPoint = TiPlaneRect.r_ur;
-			(void) DBSrLabelLoc(dummy, av[1], cmdDumpFunc,
+			(void) DBSrLabelLoc(dummy, av[2], cmdDumpFunc,
 					    &childPoint);
 			if (childPoint.p_x == TiPlaneRect.r_xtop &&
 			    childPoint.p_y == TiPlaneRect.r_ytop)
 			{
 			    TxError("Couldn't find label \"%s\" in cell \"%s\".\n",
-				    av[1], cmd->tx_argv[1]);
+				    av[2], cmd->tx_argv[1]);
 			    return FALSE;
 			}
+			av += 1;
+			ac -= 1;
+		    }
+		    else if (ac >= 3)	/* Coordinate pair */
+		    {
+			childPoint.p_x = cmdParseCoord(w, av[1], TRUE, TRUE);
+			childPoint.p_y = cmdParseCoord(w, av[2], TRUE, FALSE);
+			av += 1;
+			ac -= 1;
+		    }
+		    else
+		    {
+			TxError("Must provide two valid coordinates\n");
+			goto usage;
 		    }
 		    av += 2;
 		    ac -= 2;
 		}
 		hasChild = TRUE;
 		break;
-	    case  1:	/* Parent */
+
+	    case  IDX_PARENT:	/* "parent" */
 		if (ac < 2)
 		{
 		    TxError("Keyword must be followed by a reference point\n");
 		    goto usage;
-	    }
-		//else if (ac == 3) # error case: getcell cellname child 0 0 parent ll v 0 0 -> (ac > 3) -> read 0 as label 
-		else if (ac >= 3 && StrIsInt(av[1]) && StrIsInt(av[2]))
-		{
-		    editPoint.p_x = cmdParseCoord(w, av[1], TRUE, TRUE);
-		    editPoint.p_y = cmdParseCoord(w, av[2], TRUE, FALSE);
-		    av += 3;
-		    ac -= 3;
-		    GeoTransPoint(&EditToRootTransform, &editPoint,
-				  &rootPoint);
 		}
 		else
 		{
 		    p = Lookup(av[1], refPointNames);
-		    if (p == 0) /* lower left */
+		    if (p == IDX_LL)	/* lower left */
 		    {
 			if (!ToolGetBox(&rootDef, &rootBox) ||
 			    (rootDef != EditRootDef)) goto box_error;
 			rootPoint.p_x = rootBox.r_ll.p_x;
 			rootPoint.p_y = rootBox.r_ll.p_y;
 		    }
-		    else if (p == 1) /* lower right */
+		    else if (p == IDX_LR) /* lower right */
 		    {
 			if (!ToolGetBox(&rootDef, &rootBox) ||
 			    (rootDef != EditRootDef)) goto box_error;
 			rootPoint.p_x = rootBox.r_ur.p_x;
 			rootPoint.p_y = rootBox.r_ll.p_y;
 		    }
-		    else if (p == 2) /* upper left */
+		    else if (p == IDX_UL) /* upper left */
 		    {
 			if (!ToolGetBox(&rootDef, &rootBox) ||
 			    (rootDef != EditRootDef)) goto box_error;
 			rootPoint.p_x = rootBox.r_ll.p_x;
 			rootPoint.p_y = rootBox.r_ur.p_y;
 		    }
-		    else if (p == 3) /* upper right */
+		    else if (p == IDX_UR) /* upper right */
 		    {
 			if (!ToolGetBox(&rootDef, &rootBox) ||
 			    (rootDef != EditRootDef)) goto box_error;
 			rootPoint.p_x = rootBox.r_ur.p_x;
 			rootPoint.p_y = rootBox.r_ur.p_y;
 		    }
-		    else
+		    else if ((p == IDX_LABEL) && (ac >= 3))	/* label */
 		    {
 			for (lab = editDef->cd_labels; lab; lab = lab->lab_next)
-			    if (strcmp(lab->lab_text, av[1]) == 0)
+			    if (strcmp(lab->lab_text, av[2]) == 0)
 				break;
 
 			if (lab == NULL)
 			{
 			    TxError("Couldn't find label \"%s\" in edit cell.\n",
-				    av[1]);
+				    av[2]);
 			    return FALSE;
 			}
 			editPoint = lab->lab_rect.r_ll;
 			GeoTransPoint(&EditToRootTransform, &editPoint,
 				      &rootPoint);
+			av += 1;
+			ac -= 1;
+		    }
+		    else if (ac >= 3)	/* Coordinate pair */
+		    {
+			editPoint.p_x = cmdParseCoord(w, av[1], TRUE, TRUE);
+			editPoint.p_y = cmdParseCoord(w, av[2], TRUE, FALSE);
+			av += 1;
+			ac -= 1;
+			GeoTransPoint(&EditToRootTransform, &editPoint,
+				  &rootPoint);
+		    }
+		    else
+		    {
+			TxError("Must provide two valid coordinates\n");
+			goto usage;
 		    }
 		    av += 2;
 		    ac -= 2;
 		}
 		hasRoot = TRUE;
 		break;
-	    case  2:	/* 0 */
+	    case  IDX_ZERO:	/* "0" */
 		tx_cell = &GeoIdentityTransform;
 transform_cell:
 		if (ac < 2 )
@@ -5130,109 +5234,117 @@ default_action:
 		    }
 		    av += 1;
 		    ac -= 1;
-	    }
-		// error case: getcell cellname v 0 0 -> read 0 in kwdNames -> goto default transform
-		// av[1] = "0", "90", "180", "270" case -> av[1] must mean editpoint coordinate
-		else if (Lookup(av[1], kwdNames)>=0 && Lookup(av[1], kwdNames)!= 2 && strcmp(av[1],"90") && strcmp(av[1],"180") && strcmp(av[1],"270"))
+		}
+
+		/*
+		 * Error case:
+		 * getcell cellname v 0 0 ->
+		 *	read 0 in kwdNames
+		 *	goto default transform
+		 * av[1] = "0", "90", "180", "270" case ->
+		 *	av[1] must mean editpoint coordinate
+		 */
+
+		else if (Lookup(av[1], kwdNames) >= 0 &&
+			Lookup(av[1], kwdNames) != 2 &&
+			strcmp(av[1], "90") &&
+			strcmp(av[1], "180") &&
+			strcmp(av[1], "270"))
 		{
 		    goto default_action;
 		}
 		else
 		{
-		    if (StrIsInt(av[1]))
+		    p = Lookup(av[1], refPointNames);
+		    if (p == IDX_LL) /* lower left */
 		    {
-			editPoint.p_x = atoi(av[1]);
-			if (ac < 3 || !StrIsInt(av[2]))
+			editPoint.p_x = bbox.r_ll.p_x;
+			editPoint.p_y = bbox.r_ll.p_y;
+		    }
+		    else if (p == IDX_LR) /* lower right */
+		    {
+			editPoint.p_x = bbox.r_ur.p_x;
+			editPoint.p_y = bbox.r_ll.p_y;
+		    }
+		    else if (p == IDX_UL) /* upper left */
+		    {
+			editPoint.p_x = bbox.r_ll.p_x;
+			editPoint.p_y = bbox.r_ur.p_y;
+		    }
+		    else if (p == IDX_UR) /* upper right */
+		    {
+			editPoint.p_x = bbox.r_ur.p_x;
+			editPoint.p_y = bbox.r_ur.p_y;
+		    }
+		    else if ((p == IDX_LABEL) && (ac >= 3))	/* label */
+		    {
+			editPoint = TiPlaneRect.r_ur;
+			(void) DBSrLabelLoc(dummy, av[1], cmdDumpFunc, &editPoint);
+			if (editPoint.p_x == TiPlaneRect.r_xtop &&
+				editPoint.p_y == TiPlaneRect.r_ytop)
 			{
-			    TxError("Must provide two coordinates\n");
-			    goto usage;
+			    TxError("Couldn't find label \"%s\" in cell \"%s\".\n",
+					av[1], cmd->tx_argv[1]);
+			    return FALSE;
 			}
-			editPoint.p_y = atoi(av[2]);
-			av += 3;
-			ac -= 3;
+			av += 1;
+			ac -= 1;
+		    }
+		    else if (ac >= 3)	/* Coordinate pair */
+		    {
+			editPoint.p_x = cmdParseCoord(w, av[1], TRUE, TRUE);
+			editPoint.p_y = cmdParseCoord(w, av[2], TRUE, FALSE);
+			av += 1;
+			ac -= 1;
 		    }
 		    else
 		    {
-			p = Lookup(av[1], refPointNames);
-			if (p == 0) /* lower left */
-			{
-			    editPoint.p_x = bbox.r_ll.p_x;
-			    editPoint.p_y = bbox.r_ll.p_y;
-			}
-			else if (p == 1) /* lower right */
-			{
-			    editPoint.p_x = bbox.r_ur.p_x;
-			    editPoint.p_y = bbox.r_ll.p_y;
-			}
-			else if (p == 2) /* upper left */
-			{
-			    editPoint.p_x = bbox.r_ll.p_x;
-			    editPoint.p_y = bbox.r_ur.p_y;
-			}
-			else if (p == 3) /* upper right */
-			{
-			    editPoint.p_x = bbox.r_ur.p_x;
-			    editPoint.p_y = bbox.r_ur.p_y;
-			}
-			else
-			{
-			    editPoint = TiPlaneRect.r_ur;
-			    (void) DBSrLabelLoc(dummy, av[1], cmdDumpFunc,
-						&editPoint);
-			    if (editPoint.p_x == TiPlaneRect.r_xtop &&
-				editPoint.p_y == TiPlaneRect.r_ytop)
-			    {
-				TxError("Couldn't find label \"%s\" in cell \"%s\".\n",
-					av[1], cmd->tx_argv[1]);
-				return FALSE;
-			    }
-			}
-			av += 2;
-			ac -= 2;
+			TxError("Must provide two valid coordinates\n");
+			goto usage;
 		    }
-		    {
-			Point p;
+		    av += 2;
+		    ac -= 2;
 
-			GeoTransPoint(tx_cell, &editPoint, &p);
-			GeoTranslateTrans(tx_cell, editPoint.p_x - p.p_x,
-					  editPoint.p_y - p.p_y, &trans_cell);
-		    }
+		    GeoTransPoint(tx_cell, &editPoint, &locp);
+		    GeoTranslateTrans(tx_cell, editPoint.p_x - locp.p_x,
+					editPoint.p_y - locp.p_y,
+					&trans_cell);
 		}
 		hasTrans = TRUE;
 		break;
-	    case  3:	/* 90 */
+	    case  IDX_90:		/* "90" */
 		tx_cell = &Geo90Transform;
 		goto transform_cell;
-	    case  4:	/* 180 */
+	    case  IDX_180:		/* "180" */
 		tx_cell = &Geo180Transform;
 		goto transform_cell;
-	    case  5:	/* 270 */
+	    case  IDX_270:		/* "270" */
 		tx_cell = &Geo270Transform;
 		goto transform_cell;
-	    case  6:	/* v */
-	    case  7:	/* 0v */
+	    case  IDX_VERT:		/* "v" */
+	    case  IDX_ZERO_VERT:	/* "0v" */
 		tx_cell = &GeoUpsideDownTransform;
 		goto transform_cell;
-	    case  8:	/* 90v */
+	    case  IDX_90_VERT:		/* "90v" */
 		tx_cell = &GeoRef45Transform;
 		goto transform_cell;
-	    case  9:	/* 180v */
+	    case  IDX_180_VERT:		/* "180v" */
 		tx_cell = &GeoSidewaysTransform;
 		goto transform_cell;
-	    case  10:	/* 270v */
+	    case  IDX_270_VERT:		/* "270v" */
 		tx_cell = &GeoRef135Transform;
 		goto transform_cell;
-	    case  11:	/* h */
-	    case  12:	/* 0h */
+	    case  IDX_HORZ:		/* "h" */
+	    case  IDX_ZERO_HORZ:	/* "0h" */
 		tx_cell = &GeoSidewaysTransform;
 		goto transform_cell;
-	    case 13:	/* 90h */
+	    case  IDX_90_HORZ:		/* "90h" */
 		tx_cell = &GeoRef135Transform;
 		goto transform_cell;
-	    case 14:	/* 180h */
+	    case  IDX_180_HORZ:		/* "180h" */
 		tx_cell = &GeoUpsideDownTransform;
 		goto transform_cell;
-	    case 15:	/* 270h */
+	    case  IDX_270_HORZ:		/* "270h" */
 		tx_cell = &GeoRef45Transform;
 		goto transform_cell;
 	}
@@ -5292,15 +5404,17 @@ usage:
 	"Usage: %s cellName [child refPointChild] [parent refPointParent]\n",
 	cmdName);
     TxError("       [transform [refPointTrans]],\n");
-    TxError("       where the refPoints are either a single label name,\n");
+    TxError("       where the refPoints are one of:\n");
     TxError(
-    "       or ll for lower left corner, or lr for lower right corner\n");
+    "	    'label' followed by a single label name,\n");
     TxError(
-    "       or ul for upper left corner, or ur for upper right corner\n");
+    "       or 'll' for lower left corner, 'lr' for lower right corner,\n");
     TxError(
-    "       or a pair of integer coordinates, and the transform is one of\n");
+    "       'ul' for upper left corner, 'ur' for upper right corner,\n");
     TxError(
-    "       90, 180, 270, v, 90v, 180v, 270v, h, 90h, 180h, 270h.\n");
+    "       or a pair of coordinates.  The transform is one of:\n");
+    TxError(
+    "       90, 180, 270, v, 90v, 180v, 270v, h, 90h, 180h, or 270h.\n");
     return FALSE;
 }
 

commands/CmdE.c

@@ -781,39 +781,82 @@ cmdEraseCellsFunc(
  * Implement the "expand" command.
  *
  * Usage:
- *	expand
- *	expand toggle
+ *	expand [selection|surround|overlap|all] [toggle]
+ *
+ *	"selection" expands cells in the selection.  All other options
+ *	expand cells in the layout.  "all" expands all cells in the
+ *	layout.  "surround" expands cells which the cursor box
+ *	surrounds completely, and "overlap" expands cells which the
+ *	cursor box overlaps.
+ *
+ *	If "toggle" is specified, flips the expanded/unexpanded status.
+ *	Cells which were expanded are unexpanded, and cells which were
+ *	unexpanded are expanded.
+ *
+ *	For backwards compatibility:
+ *	"expand" alone implements "expand overlap".
+ *	"expand toggle" implements "expand selection toggle".
+ *
+ *	Also see:  CmdUnexpand
  *
  * Results:
  *	None.
  *
  * Side effects:
- *	If "toggle" is specified, flips the expanded/unexpanded status
- *	of all selected cells.  Otherwise, aren't any unexpanded cells
- *	left under the box.  May read cells in from disk, and updates
- *	bounding boxes that have changed.
+ *	Expansion state of cells is changed.  May read cells in from
+ *	disk, and update bounding boxes that have changed.
  *
  * ----------------------------------------------------------------------------
  */
 
+#define EXPAND_SELECTION      0
+#define EXPAND_SURROUND       1
+#define EXPAND_OVERLAP        2
+#define EXPAND_ALL            3
+#define EXPAND_HELP           4
+
 void
 CmdExpand(
     MagWindow *w,
     TxCommand *cmd)
 {
-    int windowMask, boxMask, d;
+    int windowMask, boxMask, d, option;
+    bool doToggle = FALSE;
+    const char * const *msg;
     Rect rootRect;
     CellUse *rootBoxUse;
     CellDef *rootBoxDef;
+
     int cmdExpandFunc(CellUse *use, int windowMask);		/* Forward reference. */
 
-    if (cmd->tx_argc > 2 || (cmd->tx_argc == 2
-	&& (strncmp(cmd->tx_argv[1], "toggle", strlen(cmd->tx_argv[1])) != 0)))
+    static const char * const cmdExpandOption[] = {
+	"selection	expand cell instances in the selection",
+	"surround	expand cell instances which the cursor box surrounds",
+	"overlap	expand cell instances which the cursor box overlaps",
+	"all		expand all cell instances",
+	NULL
+    };
+
+    if (cmd->tx_argc > 1)
     {
-	TxError("Usage: %s or %s toggle\n", cmd->tx_argv[0], cmd->tx_argv[0]);
-	return;
+	if (!strncmp(cmd->tx_argv[cmd->tx_argc - 1], "toggle",
+			strlen(cmd->tx_argv[cmd->tx_argc - 1])))
+	{
+	    doToggle = TRUE;
+	    cmd->tx_argc--;
+	}
     }
 
+    if (cmd->tx_argc > 1)
+    {
+	option = Lookup(cmd->tx_argv[1], cmdExpandOption);
+	if (option < 0) option = EXPAND_HELP;
+    }
+    else
+	option = EXPAND_OVERLAP;
+
+    if (option == EXPAND_HELP) goto badusage;
+
     windCheckOnlyWindow(&w, DBWclientID);
     if (w == (MagWindow *) NULL)
     {
@@ -844,23 +887,95 @@ CmdExpand(
             WindScale(d, 1);
 	    TxPrintf("expand: rescaled by %d\n", d);
 	    d = DBLambda[1];
-	    if (cmd->tx_argc == 2) break;	/* Don't toggle twice */
+	    if (doToggle) break;	/* Don't toggle twice */
 	}
 	(void) ToolGetBoxWindow(&rootRect, &boxMask);
 
-	if (cmd->tx_argc == 2)
-	    SelectExpand(windowMask);
-	else
+	if (option != EXPAND_SELECTION)
 	{
 	    if ((boxMask & windowMask) != windowMask)
 	    {
 		TxError("The box isn't in the same window as the cursor.\n");
 		return;
 	    }
-	    DBExpandAll(rootBoxUse, &rootRect, windowMask,
-			TRUE, cmdExpandFunc, (ClientData)(pointertype) windowMask);
+	}
+
+	switch (option)
+	{
+	    case EXPAND_SELECTION:
+		SelectExpand(windowMask,
+			(doToggle) ? DB_EXPAND_TOGGLE : DB_EXPAND,
+			(Rect *)NULL);
+		break;
+	    case EXPAND_OVERLAP:
+		if (doToggle)
+		{
+		    DBExpandAll(rootBoxUse, &rootRect, windowMask,
+				DB_EXPAND_TOGGLE | DB_EXPAND_OVERLAP,
+				cmdExpandFunc, (ClientData)(pointertype)windowMask);
+		    SelectExpand(windowMask,
+			DB_EXPAND_TOGGLE | DB_EXPAND_OVERLAP,
+			&rootRect);
+		}
+		else
+		{
+		    DBExpandAll(rootBoxUse, &rootRect, windowMask,
+				DB_EXPAND | DB_EXPAND_OVERLAP,
+				cmdExpandFunc, (ClientData)(pointertype)windowMask);
+		    SelectExpand(windowMask,
+			DB_EXPAND | DB_EXPAND_OVERLAP,
+			&rootRect);
+		}
+		break;
+	    case EXPAND_SURROUND:
+		if (doToggle)
+		{
+		    DBExpandAll(rootBoxUse, &rootRect, windowMask,
+				DB_EXPAND_TOGGLE | DB_EXPAND_SURROUND,
+				cmdExpandFunc, (ClientData)(pointertype)windowMask);
+		    SelectExpand(windowMask,
+			DB_EXPAND_TOGGLE | DB_EXPAND_SURROUND,
+			&rootRect);
+		}
+		else
+		{
+		    DBExpandAll(rootBoxUse, &rootRect, windowMask,
+				DB_EXPAND | DB_EXPAND_SURROUND,
+				cmdExpandFunc, (ClientData)(pointertype)windowMask);
+		    SelectExpand(windowMask,
+			DB_EXPAND | DB_EXPAND_SURROUND,
+			&rootRect);
+		}
+		break;
+	    case EXPAND_ALL:
+		if (doToggle)
+		{
+		    DBExpandAll(rootBoxUse, &TiPlaneRect, windowMask,
+				DB_EXPAND | DB_EXPAND_OVERLAP,
+				cmdExpandFunc, (ClientData)(pointertype)windowMask);
+		    SelectExpand(windowMask,
+			DB_EXPAND | DB_EXPAND_OVERLAP,
+			(Rect *)NULL);
+		}
+		else
+		{
+		    DBExpandAll(rootBoxUse, &TiPlaneRect, windowMask,
+				DB_EXPAND | DB_EXPAND_OVERLAP,
+				cmdExpandFunc, (ClientData)(pointertype)windowMask);
+		    SelectExpand(windowMask,
+			DB_EXPAND | DB_EXPAND_OVERLAP,
+			(Rect *)NULL);
+		}
+		break;
 	}
     } while (d != DBLambda[1]);
+
+    return;
+
+badusage:
+    for (msg = &(cmdExpandOption[0]); *msg != NULL; msg++)
+	TxPrintf("    %s\n", *msg);
+    TxPrintf("    toggle	Toggle the visibility of cell instances.\n");
 }
 
 /* This function is called for each cell whose expansion status changed.
@@ -925,11 +1040,14 @@ cmdExpandFunc(
 #define	DOALL		1
 #define	DOCAPACITANCE	2
 #define	DOCOUPLING	3
-#define	DOLENGTH	4
-#define	DOLOCAL		5
-#define	DORESISTANCE	6
-#define	DOLABELCHECK	7
-#define	DOALIASES	8
+#define	DOEXTRESIST	4
+#define	DOLENGTH	5
+#define	DOLOCAL		6
+#define	DORESISTANCE	7
+#define	DOLABELCHECK	8
+#define	DOALIASES	9
+#define	DOUNIQUE       10
+#define	DOEXTRESIST2   11
 
 #define	LENCLEAR	0
 #define	LENDRIVER	1
@@ -972,11 +1090,14 @@ CmdExtract(
 	"all			all options",
 	"capacitance		extract substrate capacitance",
 	"coupling		extract coupling capacitance",
+	"extresist		extract resistance",
 	"length			compute driver-receiver pathlengths",
 	"local			put all generated files in the current directory",
-	"resistance		estimate resistance",
+	"lumped			estimate lumped resistance",
 	"labelcheck		check for connections through sticky labels",
 	"aliases		output all net name aliases",
+	"unique	 [notopports]	ensure unique node names during extraction",
+	"resistance		extract resistance (same as \"do extresist\")",
 	NULL
     };
     static const char * const cmdExtLength[] =
@@ -1120,12 +1241,13 @@ CmdExtract(
 	    }
 	    else if (argc == 2)
 	    {
+		char *halodisp;
+		halodisp = DBWPrintValue(ExtCurStyle->exts_sideCoupleHalo,
+			w, TRUE);
 #ifdef MAGIC_WRAPPER
-		Tcl_Obj *tobj;
-		tobj = Tcl_NewIntObj(ExtCurStyle->exts_sideCoupleHalo);
-		Tcl_SetObjResult(magicinterp, tobj);
+		Tcl_SetObjResult(magicinterp, Tcl_NewStringObj(halodisp, -1));
 #else
-		TxPrintf("Side overlap halo is %d\n", ExtCurStyle->exts_sideCoupleHalo);
+		TxPrintf("Side overlap halo is %s\n", halodisp);
 #endif
 		return;
 	    }
@@ -1150,12 +1272,12 @@ CmdExtract(
 	    }
 	    else if (argc == 2)
 	    {
+		char *stepdisp;
+		stepdisp = DBWPrintValue(ExtCurStyle->exts_stepSize, w, TRUE);
 #ifdef MAGIC_WRAPPER
-		Tcl_Obj *tobj;
-		tobj = Tcl_NewIntObj(ExtCurStyle->exts_stepSize);
-		Tcl_SetObjResult(magicinterp, tobj);
+		Tcl_SetObjResult(magicinterp, Tcl_NewStringObj(stepdisp, -1));
 #else
-		TxPrintf("Extraction step size is %d\n", ExtCurStyle->exts_stepSize);
+		TxPrintf("Extraction step size is %s\n", stepdisp);
 #endif
 		return;
 	    }
@@ -1277,9 +1399,12 @@ CmdExtract(
 		TxPrintf("%s capacitance\n", OPTSET(EXT_DOCAPACITANCE));
 		TxPrintf("%s coupling\n", OPTSET(EXT_DOCOUPLING));
 		TxPrintf("%s length\n", OPTSET(EXT_DOLENGTH));
-		TxPrintf("%s resistance\n", OPTSET(EXT_DORESISTANCE));
+		TxPrintf("%s lumped R\n", OPTSET(EXT_DORESISTANCE));
 		TxPrintf("%s label check\n", OPTSET(EXT_DOLABELCHECK));
 		TxPrintf("%s aliases\n", OPTSET(EXT_DOALIASES));
+		TxPrintf("%s unique\n", OPTSET(EXT_DOUNIQUE));
+		TxPrintf("%s unique notopports\n", OPTSET(EXT_DOUNIQNOTOPPORTS));
+		TxPrintf("%s resistance (extresist)\n", OPTSET(EXT_DOEXTRESIST));
 		return;
 #undef	OPTSET
 	    }
@@ -1309,6 +1434,19 @@ CmdExtract(
 		case DORESISTANCE:	option = EXT_DORESISTANCE; break;
 		case DOLABELCHECK:	option = EXT_DOLABELCHECK; break;
 		case DOALIASES:		option = EXT_DOALIASES; break;
+		case DOEXTRESIST:
+		case DOEXTRESIST2:	option = EXT_DOEXTRESIST; break;
+		case DOUNIQUE:
+		    if (argc == 4)
+		    {
+			if (!strncmp(argv[3], "notop", 5))
+			    option = EXT_DOUNIQNOTOPPORTS | EXT_DOUNIQUE;
+			else
+			    TxError("Usage:  extract do unique [notopports]\n");
+		    }
+		    else
+			option = EXT_DOUNIQUE;
+		    break;
 		case DOLOCAL:
 		    /* "extract do local" and "extract no local" are kept for
 		     * backwards compatibility, but now effectively implement

commands/CmdFI.c

@@ -102,15 +102,17 @@ struct cmdFPArg
 int
 feedPolyFunc(
     Tile *tile,
+    TileType dinfo,
     struct cmdFPArg *arg)
 {
     Rect area;
     TiToRect(tile, &area);
 
+    /* (NOTE:  Preserve information about the geometry of a diagonal tile) */
     DBWFeedbackAdd(&area, arg->text, arg->def, FEEDMAGNIFY,
         arg->style |
-                (TiGetTypeExact(tile) & (TT_DIAGONAL | TT_DIRECTION | TT_SIDE)));
-        /* (preserve information about the geometry of a diagonal tile) */
+                ((TiGetTypeExact(tile) | dinfo) &
+		(TT_DIAGONAL | TT_DIRECTION | TT_SIDE)));
     return 0;
 }
 
@@ -507,13 +509,15 @@ struct cmdFillArea *cmdFillList;	/* List of areas to fill. */
 
 void
 CmdFill(
-    MagWindow *w,		/* Window in which command was invoked. */
+    MagWindow *w,	/* Window in which command was invoked. */
     TxCommand *cmd)	/* Describes the command that was invoked. */
 {
     TileTypeBitMask maskBits;
     Rect editBox;
     SearchContext scx;
-    extern int cmdFillFunc(Tile *tile, TreeContext *cxp);
+
+    /* Forward declaration */
+    extern int cmdFillFunc(Tile *tile, TileType dinfo, TreeContext *cxp);
 
     if (cmd->tx_argc < 2 || cmd->tx_argc > 3)
     {
@@ -581,13 +585,15 @@ CmdFill(
     /* Now that we've got all the material, scan over the list
      * painting the material and freeing up the entries on the list.
      */
+    free_magic1_t mm1 = freeMagic1_init();
     while (cmdFillList != NULL)
     {
 	DBPaint(EditCellUse->cu_def, &cmdFillList->cfa_area,
 		cmdFillList->cfa_type);
-	freeMagic((char *) cmdFillList);
+	freeMagic1(&mm1, (char *) cmdFillList);
 	cmdFillList = cmdFillList->cfa_next;
     }
+    freeMagic1_end(&mm1);
 
     SelectClear();
     DBAdjustLabels(EditCellUse->cu_def, &editBox);
@@ -601,11 +607,16 @@ CmdFill(
  * paint here it may mess up the search.  Instead, the procedures
  * save areas on a list.  The list is post-processed to paint the
  * areas once the search is finished.
+ *
+ * Split tile information is unused because there is no obvious
+ * meaning to "filling" from a split tile, although probably reasonable
+ * methods could be worked out.
  */
 
 int
 cmdFillFunc(
     Tile *tile,			/* Tile to fill with. */
+    TileType dinfo,		/* Split tile information (unused) */
     TreeContext *cxp)		/* Describes state of search. */
 {
     Rect r1, r2;
@@ -841,7 +852,7 @@ CmdFindLabel(
 	return;
     };
 
-    labname = cmd->tx_argv[1 + (doglob) ? 1 : 0];
+    labname = cmd->tx_argv[1 + ((doglob) ? 1 : 0)];
     labUse = EditCellUse;
     if (labUse == NULL) labUse = (CellUse *)w->w_surfaceID;
 
@@ -1208,7 +1219,7 @@ CmdGetnode(
 	TxError("Put the cursor in a layout window\n");
 	return;
     }
-    if( is_fast == TRUE )
+    if (is_fast == TRUE)
     {
 	SimRecomputeSel = TRUE;
 	SimGetsnode();
@@ -1216,7 +1227,8 @@ CmdGetnode(
     else
 	SimGetnode();
 
-    if (SimGetnodeAlias) {			/* "erase" the hash table */
+    if (SimGetnodeAlias)		/* "erase" the hash table */
+    {
 	HashKill(&SimGNAliasTbl);
 	HashInit(&SimGNAliasTbl, 120, STRINGS);
     }
@@ -1602,7 +1614,7 @@ CmdFindNetProc(
     int			pnum, xpos, ypos;
     char 		*xstr, *ystr;
     bool		locvalid = FALSE, usefound = TRUE;
-    TileType		ttype;
+    TileType		ttype, dinfo = (TileType)0;
 
     scx.scx_use = use;
     scx.scx_trans = GeoIdentityTransform;
@@ -1640,6 +1652,7 @@ CmdFindNetProc(
 
     if ((xstr = strchr(s, '_')) != NULL)
     {
+	char *hashpos;
 	bool isNeg = FALSE;
 
         /* The characters up to the leading '_' should match one of the	*/
@@ -1683,6 +1696,17 @@ CmdFindNetProc(
 		    }
 	        }
 	    }
+
+	    /* Format variant used for node regions where a split tile
+	     * occupies the root position of the node but the tile type
+	     * belonging to the node is on the right side of the tile,
+	     * not at the location encoded into the name.  An 'x' is
+	     * added before the final hash sign.
+	     */
+	    hashpos = strrchr(s, '#');
+	    if (hashpos != NULL)
+		if (*(hashpos - 1) == 'r')
+		    dinfo = TT_DIAGONAL | TT_SIDE;
 	}
     }
 
@@ -1705,17 +1729,23 @@ checklocal:
 
     if (locvalid == TRUE)
     {
-	int findTile(Tile *tile, TileType *rtype);
+	int findTile(Tile *tile, TileType dinfo, TileAndDinfo *tad);
 	CellDef	 *targetdef = use->cu_def;
 	Plane *plane = targetdef->cd_planes[pnum];
-
-	ttype = TT_SPACE;	/* revert to space in case of failure */
+        TileAndDinfo tad;
 
 	/* Find the tile type of the tile at the specified point which	*/
-	/* exists on the plane pnum.					*/
+	/* exists on the plane pnum.  Note that in the case of a split	*/
+	/* tile region marked with "x" in the name, it does not work to	*/
+	/* call DBSrPainNMArea() because the diagonal position is not	*/
+	/* known.  findTile() determines the proper type and leaves it	*/
+	/* in the tad.tad_dinfo record.					*/
 
+	tad.tad_tile = (Tile *)NULL;
+	tad.tad_dinfo = dinfo;
 	DBSrPaintArea(NULL, plane, &localrect, &DBAllTypeBits, findTile,
-			(ClientData) &ttype);
+			(ClientData) &tad);
+	ttype = tad.tad_dinfo & TT_LEFTMASK;
     }
     else
     {
@@ -1783,7 +1813,7 @@ CmdGoto(
     MagWindow *w,
     TxCommand *cmd)
 {
-    char	*s, *nodename = cmd->tx_argv[1];
+    char	*nodename = cmd->tx_argv[1];
     Rect	rect;
     CellUse	*use;
     int		locargc;
@@ -1824,9 +1854,9 @@ CmdGoto(
     /* are multiple layers drawn at the indicated point.		*/
 
 #ifdef MAGIC_WRAPPER
-    Tcl_SetResult(magicinterp, DBTypeLongName(ttype), NULL);
+    Tcl_SetResult(magicinterp, (char*)DBTypeLongName(ttype), NULL); /* Tcl treats as const */
 #else
-    TxPrintf("node %s is type %s\n", s, DBTypeLongName(ttype));
+    TxPrintf("node %s is type %s\n", nodename, DBTypeLongName(ttype));
 #endif
 }
 
@@ -1839,20 +1869,31 @@ CmdGoto(
 int
 findTile(
     Tile *tile,
-    TileType *rtype)
+    TileType dinfo,	/* (unused) */
+    TileAndDinfo *tad)
 {
     TileType ttype;
 
+    /* Note that since all types are being searched, a split
+     * tile would cause the callback to be called twice.  But
+     * this routine will pick the indicated side from the
+     * "tad" structure and return 1 so it does not get called
+     * a second time.  The "dinfo" value passed is irrelevant.
+     */
+
     if (IsSplit(tile))
     {
-	if (SplitSide(tile))
+	if (tad->tad_dinfo & TT_SIDE)
 	    ttype = SplitRightType(tile);
 	else
 	    ttype = SplitLeftType(tile);
     }
     else
 	ttype = TiGetTypeExact(tile);
-    *rtype = ttype;
+
+    /* Leave the tile type in tad_dinfo before returning */
+    tad->tad_dinfo = ttype;
+
     return 1;			/* stop search */
 }
 

commands/CmdLQ.c

@@ -45,9 +45,8 @@ static const char rcsid[] __attribute__ ((unused)) = "$Header: /usr/cvsroot/magi
 #include "utils/undo.h"
 #include "select/select.h"
 #include "netmenu/netmenu.h"
-
-/* C99 compat */
 #include "cif/cif.h"
+#include "cif/CIFint.h"
 
 /* Forward declarations */
 
@@ -518,14 +517,14 @@ CmdLoad(
 
 	    DBExpandAll(topuse, &(topuse->cu_bbox),
 			((DBWclientRec *)w->w_clientData)->dbw_bitmask,
-			TRUE, keepGoing, NULL);
+			DB_EXPAND, keepGoing, NULL);
 
 	    DBExpandAll(topuse, &(topuse->cu_bbox),
 			((DBWclientRec *)w->w_clientData)->dbw_bitmask,
-			FALSE, keepGoing, NULL);
+			DB_UNEXPAND, keepGoing, NULL);
 	    DBExpand(topuse,
 			((DBWclientRec *)w->w_clientData)->dbw_bitmask,
-			TRUE);
+			DB_EXPAND);
 
 	    /* We don't want to save and restore DBLambda, because      */
 	    /* loading the file may change their values.  Instead, we   */
@@ -2176,11 +2175,15 @@ parseindex:
 		{
 		    if ((int)sl->lab_port == idx)
 		    {
-			TxError("Port index %d is already used by port %s.\n"
-				"Use command \"port index %d\" to force "
-				"equivalence after defining the port.\n",
-				idx, sl->lab_text, idx);
-			return;
+			/* This is only an error if port name doesn't match */
+			if (strcmp(sl->lab_text, lab->lab_text))
+			{
+			    TxError("Port index %d is already used by port %s.\n"
+					"Use command \"port index %d\" to force "
+					"equivalence after defining the port.\n",
+					idx, sl->lab_text, idx);
+			    return;
+			}
 		    }
 		}
 	    }
@@ -2292,6 +2295,8 @@ parsepositions:
     editDef->cd_flags |= (CDMODIFIED | CDGETNEWSTAMP);
 }
 
+#define PROPERTY_TYPE_COMPAT	4	/* Last entry in cmdPropertyType */
+
 /*
  * ----------------------------------------------------------------------------
  *
@@ -2315,47 +2320,448 @@ parsepositions:
 void
 CmdDoProperty(
     CellDef *def,
+    MagWindow *w,
     TxCommand *cmd,
     int argstart)
 {
-    int printPropertiesFunc();
+    PropertyRecord *proprec = NULL;
     char *value;
-    bool propfound;
+    bool propfound, dolist;
+    int proptype, proplen, propvalue, i;
+    dlong dvalue;
     int locargc = cmd->tx_argc - argstart + 1;
+#ifdef MAGIC_WRAPPER
+    Tcl_Obj *tobj;
+#endif
+
+    /* Forward declarations */
+    int printPropertiesFunc();
+    int printPlanePropFunc();		
+
+    /* These should match the property codes in database.h.in, except
+     * for "compat" which must come at the end.
+     */
+    static const char * const cmdPropertyType[] = {
+	"string", "integer", "dimension", "double", "plane", "compat", NULL
+    };
+
+    /* If the first keyword is "list", then set dolist and increment
+     * the starting argument position.
+     */
+    dolist = FALSE;
+    if (locargc > 1)
+    {
+	if (!strcmp(cmd->tx_argv[argstart], "list"))
+	{
+	    dolist = TRUE;
+	    locargc--;
+	    argstart++;
+	}
+    }
+
+    /* If a property type is given, parse it and then strip it from
+     * the arguments list.
+     */
+    if (locargc > 1)
+    {
+	proptype = Lookup(cmd->tx_argv[argstart], cmdPropertyType);
+	if (proptype >= 0)
+	{
+	    if (proptype != PROPERTY_TYPE_COMPAT)
+	    {
+		locargc--;
+		argstart++;
+	    }
+	}
+	else
+	    proptype = PROPERTY_TYPE_STRING;	/* default */
+    }
+    else
+	proptype = PROPERTY_TYPE_STRING;	/* default */
 
     if (locargc == 1)
     {
+#ifdef MAGIC_WRAPPER
+	Tcl_Obj *tobj;
+	/* Create an empty list for the interpreter result; the
+	 * printPropertiesFunc() function will append values to it.
+	 */
+	tobj = Tcl_NewListObj(0, NULL);
+	Tcl_SetObjResult(magicinterp, tobj);
+#endif
 	/* print all properties and their values */
-	DBPropEnum(def, printPropertiesFunc, NULL);
+	DBPropEnum(def, printPropertiesFunc, (ClientData)w);
     }
 
     else if (locargc == 2)
     {
-	/* print the value of the indicated property */
-	value = (char *)DBPropGet(def, cmd->tx_argv[argstart], &propfound);
-	if (propfound)
+	/* If the property type was "compat", then give the state of the
+	 * compatibility flag and return.
+	 */
+	if (proptype == PROPERTY_TYPE_COMPAT)
+	{
 #ifdef MAGIC_WRAPPER
-	    Tcl_SetResult(magicinterp, value, NULL);
+	    Tcl_SetObjResult(magicinterp, Tcl_NewBooleanObj(DBPropCompat));
 #else
-	    TxPrintf("%s", value);
+	    TxPrintf("%s\n", (DBPropCompat == TRUE) ? "True" : "False");
 #endif
+	    return;
+	}
+
+	/* Print the value of the indicated property */
+	proprec = (PropertyRecord *)DBPropGet(def, cmd->tx_argv[argstart], &propfound);
+	if (propfound)
+	{
+	    proptype = proprec->prop_type;
+#ifdef MAGIC_WRAPPER
+	    switch (proptype)
+	    {
+		case PROPERTY_TYPE_STRING:
+		    Tcl_SetResult(magicinterp, proprec->prop_value.prop_string, NULL);
+		    break;
+		case PROPERTY_TYPE_INTEGER:
+		    if (proprec->prop_len == 1)
+			Tcl_SetObjResult(magicinterp,
+				Tcl_NewIntObj(proprec->prop_value.prop_integer[0]));
+		    else
+		    {
+			tobj = Tcl_NewListObj(0, NULL);
+			for (i = 0; i < proprec->prop_len; i++)
+			    Tcl_ListObjAppendElement(magicinterp, tobj,
+					Tcl_NewIntObj(
+					proprec->prop_value.prop_integer[i]));
+			Tcl_SetObjResult(magicinterp, tobj);
+		    }
+		    break;
+		case PROPERTY_TYPE_DIMENSION:
+		    if (proprec->prop_len == 1)
+			Tcl_SetResult(magicinterp,
+				DBWPrintValue(proprec->prop_value.prop_integer[0],
+				w, TRUE), NULL);
+		    else
+		    {
+			tobj = Tcl_NewListObj(0, NULL);
+			for (i = 0; i < proprec->prop_len; i++)
+			    Tcl_ListObjAppendElement(magicinterp, tobj,
+					Tcl_NewStringObj(DBWPrintValue(
+					proprec->prop_value.prop_integer[i], w,
+					((i % 2) == 0) ? TRUE : FALSE), -1));
+			Tcl_SetObjResult(magicinterp, tobj);
+		    }
+		    break;
+		case PROPERTY_TYPE_PLANE:
+		    tobj = Tcl_NewListObj(0, NULL);
+		    DBSrPaintArea(PlaneGetHint(proprec->prop_value.prop_plane),
+				proprec->prop_value.prop_plane,
+				&TiPlaneRect, &CIFSolidBits, printPlanePropFunc,
+				(ClientData)tobj);
+		    Tcl_SetObjResult(magicinterp, tobj);
+		    break;
+		case PROPERTY_TYPE_DOUBLE:
+		    if (proprec->prop_len == 1)
+			Tcl_SetObjResult(magicinterp,
+				Tcl_NewWideIntObj((Tcl_WideInt)
+				proprec->prop_value.prop_double[0]));
+		    else
+		    {
+			tobj = Tcl_NewListObj(0, NULL);
+			for (i = 0; i < proprec->prop_len; i++)
+			    Tcl_ListObjAppendElement(magicinterp, tobj,
+					Tcl_NewWideIntObj((Tcl_WideInt)
+					proprec->prop_value.prop_double[i]));
+			Tcl_SetObjResult(magicinterp, tobj);
+		    }
+		    break;
+	    }
+#else
+	    switch (proptype)
+	    {
+		case PROPERTY_TYPE_STRING:
+		    TxPrintf("%s\n", proprec->prop_value.prop_string);
+		    break;
+		case PROPERTY_TYPE_INTEGER:
+		    for (i = 0; i < proprec->prop_len; i++)
+			TxPrintf("%d ", proprec->prop_value.prop_integer[i]);
+		    TxPrintf("\n");
+		    break;
+		case PROPERTY_TYPE_DIMENSION:
+		    for (i = 0; i < proprec->prop_len; i++)
+			TxPrintf("%s ", DBWPrintValue(
+				proprec->prop_value.prop_integer[i], w,
+				((i % 2) == 0) ? TRUE : FALSE));
+		
+		    TxPrintf("\n");
+		    break;
+		case PROPERTY_TYPE_PLANE:
+		    DBSrPaintArea(PlaneGetHint(proprec->prop_value.prop_plane),
+				proprec->prop_value.prop_plane,
+				&TiPlaneRect, &CIFSolidBits, printPlanePropFunc,
+				(ClientData)NULL);
+		    TxPrintf("\n");
+		    break;
+		case PROPERTY_TYPE_DOUBLE:
+		    for (i = 0; i < proprec->prop_len; i++)
+			TxPrintf( "%"DLONG_PREFIX"d",
+				proprec->prop_value.prop_double[i]);
+		    TxPrintf("\n");
+		    break;
+	    }
+#endif
+	}
 	else {
 #ifdef MAGIC_WRAPPER
 	    /* If the command was "cellname list property ...", then	*/
 	    /* just return NULL if the property was not found.		*/
-	    if (strcmp(cmd->tx_argv[1], "list"))
+	    if (!dolist)
 #endif
-		TxError("Property name \"%s\" is not defined\n", cmd->tx_argv[1]);
+		TxError("Property name \"%s\" is not defined\n", cmd->tx_argv[argstart]);
 	}
     }
-    else if (locargc == 3)
+    else if (locargc >= 3)
     {
+	/* If the property type was "compat", then set the state of the
+	 * compatibility flag and return.
+	 */
+	if (proptype == PROPERTY_TYPE_COMPAT)
+	{
+	    int idx;
+	    static const char * const cmdPropYesNo[] = {
+			"disable", "no", "false", "off", "0",
+			"enable", "yes", "true", "on", "1", 0 };
+	    idx = Lookup(cmd->tx_argv[2], cmdPropYesNo);
+	    if (idx < 0)
+	    {
+		TxError("Unknown property compat option \"%s\"\n", cmd->tx_argv[2]);
+		return;
+	    }
+	    DBPropCompat = (idx <= 4) ? FALSE : TRUE;
+	    return;
+	}
+
+	/* Catch the following known reserved keywords and cast them to the
+	 * expected property type.  If any property type was already given
+	 * to the command, it is overridden.  This ensures that the reserved
+	 * keyword functions work correctly.
+	 *
+	 * GDS_START, GDS_END:  PROPERTY_TYPE_DOUBLE
+	 * MASKHINTS_*:  PROPERTY_TYPE_PLANE
+	 * FIXED_BBOX:  PROPERTY_TYPE_DIMENSION
+	 */
+	if (!strcmp(cmd->tx_argv[argstart], "GDS_START"))
+	    proptype = PROPERTY_TYPE_DOUBLE;
+	else if (!strcmp(cmd->tx_argv[argstart], "GDS_END"))
+	    proptype = PROPERTY_TYPE_DOUBLE;
+	else if (!strcmp(cmd->tx_argv[argstart], "GDS_FILE"))
+	    proptype = PROPERTY_TYPE_STRING;
+	else if (!strcmp(cmd->tx_argv[argstart], "FIXED_BBOX"))
+	    proptype = PROPERTY_TYPE_DIMENSION;
+	else if (!strcmp(cmd->tx_argv[argstart], "OBS_BBOX"))
+	    proptype = PROPERTY_TYPE_DIMENSION;
+	else if (!strncmp(cmd->tx_argv[argstart], "MASKHINTS_", 10))
+	    proptype = PROPERTY_TYPE_PLANE;
+
 	if (strlen(cmd->tx_argv[argstart + 1]) == 0)
 	    DBPropPut(def, cmd->tx_argv[argstart], NULL);
 	else
 	{
-	    value = StrDup((char **)NULL, cmd->tx_argv[argstart + 1]);
-	    DBPropPut(def, cmd->tx_argv[argstart], value);
+	    if (proptype == PROPERTY_TYPE_STRING)
+	    {
+		proplen = strlen(cmd->tx_argv[argstart + 1]);
+		proprec = (PropertyRecord *)mallocMagic(sizeof(PropertyRecord) -
+			7 + proplen);
+		proprec->prop_type = proptype;
+		proprec->prop_len = proplen;
+		strcpy(proprec->prop_value.prop_string, cmd->tx_argv[argstart + 1]);
+	    }
+	    else	/* All non-string properties */
+	    {
+		Plane *plane;
+		Rect r;
+
+		/* Two choices:  If locargc == 3 then all values are in one
+		 * argument.  If locargc > 3, then parse each argument as a
+		 * separate value.
+		 */
+		if (locargc > 3)
+		{
+		    proplen = locargc - 2;
+		    if (proptype == PROPERTY_TYPE_DOUBLE)
+		        proprec = (PropertyRecord *)mallocMagic(sizeof(PropertyRecord) +
+				(proplen - 1)*sizeof(dlong));
+		    else if (proptype == PROPERTY_TYPE_PLANE)
+		    {
+		        proprec = (PropertyRecord *)mallocMagic(sizeof(PropertyRecord));
+			plane = DBNewPlane((ClientData)TT_SPACE);
+			proprec->prop_value.prop_plane = plane;
+		    }
+		    else
+		        proprec = (PropertyRecord *)mallocMagic(sizeof(PropertyRecord) +
+				(proplen - 2)*sizeof(int));
+		    proprec->prop_type = proptype;
+		    proprec->prop_len = proplen;
+
+		    for (i = 1; i < locargc - 1; i++)
+		    {
+			if (proptype == PROPERTY_TYPE_INTEGER)
+			{
+			    if (sscanf(cmd->tx_argv[argstart + i], "%d",
+					&propvalue) == 1)
+				proprec->prop_value.prop_integer[i - 1] = propvalue;
+			    else
+			    {
+				TxError("Unable to parse value \"%s\" as an integer\n",
+					cmd->tx_argv[argstart + i]);
+				proprec->prop_value.prop_integer[i - 1] = 0;
+			    }
+			}
+			else if (proptype == PROPERTY_TYPE_DOUBLE)
+			{
+			    if (sscanf(cmd->tx_argv[argstart + i], "%"DLONG_PREFIX"d",
+					&dvalue) == 1)
+				proprec->prop_value.prop_double[i - 1] = dvalue;
+			    else
+			    {
+				TxError("Unable to parse value \"%s\" as an integer\n",
+					cmd->tx_argv[argstart + i]);
+				proprec->prop_value.prop_double[i - 1] = 0;
+			    }
+			}
+			else if (proptype == PROPERTY_TYPE_PLANE)
+			{
+			    propvalue = cmdParseCoord(w, cmd->tx_argv[argstart + i],
+					FALSE, ((i % 2) == 0) ? FALSE : TRUE);
+			    switch ((i - 1) % 4)
+			    {
+				case 0:
+				    r.r_xbot = propvalue;
+				    break;
+				case 1:
+				    r.r_ybot = propvalue;
+				    break;
+				case 2:
+				    r.r_xtop = propvalue;
+				    break;
+				case 3:
+				    r.r_ytop = propvalue;
+				    DBPaintPlane(plane, &r, CIFPaintTable,
+						(PaintUndoInfo *)NULL);
+				    break;
+			    }
+			}
+			else	/* PROPERTY_TYPE_DIMENSION */
+			{
+			    propvalue = cmdParseCoord(w, cmd->tx_argv[argstart + i],
+					FALSE, ((i % 2) == 0) ? FALSE : TRUE);
+			    proprec->prop_value.prop_integer[i - 1] = propvalue;
+			}
+	 	    }
+		}
+		else
+		{
+		    /* Make two passes through the argument string, once to get
+		     * the valid number of arguments, then again to parse the
+		     * values, once the property record has been allocated
+		     */
+		    value = cmd->tx_argv[argstart + 1];
+		    for (proplen = 0; *value != '\0'; )
+		    {
+			if (isspace(*value) && (*value != '\0')) value++;
+			if (!isspace(*value))
+			{
+			    proplen++;
+			    while (!isspace(*value) && (*value != '\0')) value++;
+			}
+		    }
+		    if (proplen > 0)
+		    {
+			if (proptype == PROPERTY_TYPE_PLANE)
+			{
+			    proprec = (PropertyRecord *)mallocMagic(sizeof(PropertyRecord));
+			    plane = DBNewPlane((ClientData)TT_SPACE);
+			    proprec->prop_value.prop_plane = plane;
+			} else {
+			    proprec = (PropertyRecord *)mallocMagic(
+					sizeof(PropertyRecord) +
+					(proplen - 2) * sizeof(int));
+			}
+			proprec->prop_type = proptype;
+			proprec->prop_len = proplen;
+		    }
+
+		    /* Second pass */
+		    value = cmd->tx_argv[argstart + 1];
+		    for (proplen = 0; proplen < proprec->prop_len; proplen++)
+		    {
+			if (isspace(*value) && (*value != '\0')) value++;
+			if (!isspace(*value))
+			{
+			    char *spptr, spchar;
+			    /* cmdParseCoord() can only handle one value at a
+			     * time, so look ahead and null out the next space
+			     * character if there is one.
+			     */
+			    spptr = value + 1;
+			    while (!isspace(*spptr) && (*spptr != '\0')) spptr++;
+			    spchar = *spptr;
+			    *spptr = '\0';
+			
+			    if (proptype == PROPERTY_TYPE_INTEGER)
+			    {
+			        if (sscanf(value, "%d", &propvalue) != 1)
+				{
+				    TxError("Unable to parse integer "
+						"value from \"%s\"\n",
+						value);
+				    propvalue = 0;
+				}
+			        proprec->prop_value.prop_integer[proplen] = propvalue;
+			    }
+			    else if (proptype == PROPERTY_TYPE_DOUBLE)
+			    {
+			        if (sscanf(value, "%"DLONG_PREFIX"d", &dvalue) != 1)
+				{
+				    TxError("Unable to parse integer "
+						"value from \"%s\"\n",
+						value);
+				    propvalue = 0;
+				}
+			        proprec->prop_value.prop_double[proplen] = dvalue;
+			    }
+			    else if (proptype == PROPERTY_TYPE_PLANE)
+			    {
+				propvalue = cmdParseCoord(w, value, FALSE,
+					((proplen % 2) == 0) ? TRUE : FALSE);
+				switch (proplen % 4)
+				{
+				    case 0:
+					r.r_xbot = propvalue;
+					break;
+				    case 1:
+					r.r_ybot = propvalue;
+					break;
+				    case 2:
+					r.r_xtop = propvalue;
+					break;
+				    case 3:
+					r.r_ytop = propvalue;
+					DBPaintPlane(plane, &r, CIFPaintTable,
+						(PaintUndoInfo *)NULL);
+					break;
+				}
+			    }
+			    else	/* PROPERTY_TYPE_DIMENSION */
+			    {
+				propvalue = cmdParseCoord(w, value, FALSE,
+					((proplen % 2) == 0) ? TRUE : FALSE);
+			        proprec->prop_value.prop_integer[proplen] = propvalue;
+			    }
+			    *spptr = spchar;
+			    while (!isspace(*value) && (*value != '\0')) value++;
+			}
+		    }
+		}
+	    }
+	    DBPropPut(def, cmd->tx_argv[argstart], proprec);
 	}
 	def->cd_flags |= (CDMODIFIED | CDGETNEWSTAMP);
     }
@@ -2376,10 +2782,14 @@ CmdDoProperty(
  * defined in database/DBprop.c.
  *
  * Usage:
- *	property [name] [value]
+ *	property [string|integer|dimension] [name] [value]
  *
- * "name" is a unique string tag for the property, and "value" is its
- * string value.
+ * If the first argument is present, it must be one of the known
+ * keywords, and determines the form in which "value" is interpreted and
+ * stored.  "name" is a unique string tag for the property.  "value" is
+ * the value of the property, which is either a string, integer, or a
+ * list of integers.  The difference between an "integer" and a "dimension"
+ * is that all values which are dimensions are scaled with internal units.
  *
  * Results:
  *	None.
@@ -2406,9 +2816,62 @@ CmdProperty(
     else
 	def = ((CellUse *) w->w_surfaceID)->cu_def;
 
-    CmdDoProperty(def, cmd, 1);
+    CmdDoProperty(def, w, cmd, 1);
 }
 
+/*
+ * ----------------------------------------------------------------------------
+ * Callback function for printing values from a Plane property
+ * ----------------------------------------------------------------------------
+ */
+
+#ifdef MAGIC_WRAPPER 
+int
+printPlanePropFunc(
+    Tile *tile,
+    TileType dinfo,
+    Tcl_Obj *lobj)
+{
+    Rect r;
+    MagWindow *w;
+
+    TiToRect(tile, &r);
+    windCheckOnlyWindow(&w, DBWclientID); 
+
+    Tcl_ListObjAppendElement(magicinterp, lobj,
+		Tcl_NewStringObj(DBWPrintValue(r.r_xbot, w, TRUE), -1));
+    Tcl_ListObjAppendElement(magicinterp, lobj,
+		Tcl_NewStringObj(DBWPrintValue(r.r_ybot, w, FALSE), -1));
+    Tcl_ListObjAppendElement(magicinterp, lobj,
+		Tcl_NewStringObj(DBWPrintValue(r.r_xtop, w, TRUE), -1));
+    Tcl_ListObjAppendElement(magicinterp, lobj,
+		Tcl_NewStringObj(DBWPrintValue(r.r_ytop, w, FALSE), -1));
+    return 0;
+}
+
+#else
+
+int
+printPlanePropFunc(
+    Tile *tile,
+    TileType dinfo,
+    ClientData cdata)	/* (unused) */
+{
+    Rect r;
+    MagWindow *w;
+
+    TiToRect(tile, &r);
+    windCheckOnlyWindow(&w, DBWclientID); 
+
+    TxPrintf("%s ", DBWPrintValue(r.r_xbot, w, TRUE));
+    TxPrintf("%s ", DBWPrintValue(r.r_ybot, w, FALSE));
+    TxPrintf("%s ", DBWPrintValue(r.r_xtop, w, TRUE));
+    TxPrintf("%s ", DBWPrintValue(r.r_ytop, w, FALSE));
+    return 0;
+}
+
+#endif
+
 /*
  * ----------------------------------------------------------------------------
  * Callback function for printing a single property key:value pair
@@ -2418,27 +2881,84 @@ CmdProperty(
 int
 printPropertiesFunc(
     const char *name,
-    ClientData value,
-    ClientData cdata) /* not used */
+    PropertyRecord *proprec,
+    MagWindow *w)
 {
-#ifdef MAGIC_WRAPPER
-    char *keyvalue;
+    int i;
 
-    if (value == NULL)
+#ifdef MAGIC_WRAPPER
+    Tcl_Obj *tobj, *lobj;
+
+    tobj = Tcl_GetObjResult(magicinterp);
+    lobj = Tcl_NewListObj(0, NULL);
+    Tcl_ListObjAppendElement(magicinterp, lobj, Tcl_NewStringObj(name, -1));
+
+    switch (proprec->prop_type)
     {
-	keyvalue = (char *)mallocMagic(strlen(name) + 4);
-	sprintf(keyvalue, "%s {}", name);
+	case PROPERTY_TYPE_STRING:
+    	    Tcl_ListObjAppendElement(magicinterp, lobj,
+			Tcl_NewStringObj(proprec->prop_value.prop_string, -1));
+	    break;
+	case PROPERTY_TYPE_INTEGER:
+	    for (i = 0; i < proprec->prop_len; i++)
+    	        Tcl_ListObjAppendElement(magicinterp, lobj,
+			Tcl_NewIntObj(proprec->prop_value.prop_integer[i]));
+	    break;
+	case PROPERTY_TYPE_DIMENSION:
+	    for (i = 0; i < proprec->prop_len; i++)
+    	        Tcl_ListObjAppendElement(magicinterp, lobj,
+			Tcl_NewStringObj(
+			DBWPrintValue(proprec->prop_value.prop_integer[i],
+			w, ((i % 2) == 0) ? TRUE : FALSE), -1));
+	    break;
+	case PROPERTY_TYPE_PLANE:
+	    DBSrPaintArea(PlaneGetHint(proprec->prop_value.prop_plane),
+			proprec->prop_value.prop_plane,
+			&TiPlaneRect, &CIFSolidBits, printPlanePropFunc,
+			(ClientData)lobj);
+	    break;
+	case PROPERTY_TYPE_DOUBLE:
+	    for (i = 0; i < proprec->prop_len; i++)
+    	        Tcl_ListObjAppendElement(magicinterp, lobj,
+			Tcl_NewWideIntObj(proprec->prop_value.prop_double[i]));
+	    break;
     }
-    else
-    {
-	keyvalue = (char *)mallocMagic(strlen(name) + strlen((char *)value) + 2);
-	sprintf(keyvalue, "%s %s", name, (char *)value);
-    }
-    Tcl_AppendElement(magicinterp, keyvalue);
-    freeMagic(keyvalue);
+    Tcl_ListObjAppendElement(magicinterp, tobj, lobj);
+    Tcl_SetObjResult(magicinterp, tobj);
 
 #else
-    TxPrintf("%s = %s\n", name, value);
+    switch (proprec->prop_type)
+    {
+	case PROPERTY_TYPE_STRING:
+	    TxPrintf("%s = %s\n", name, (const char *)proprec->prop_value.prop_string);
+	    break;
+	case PROPERTY_TYPE_INTEGER:
+	    TxPrintf("%s = ", name);
+	    for (i = 0; i < proprec->prop_len; i++)
+		TxPrintf("%d ", proprec->prop_value.prop_integer[i]);
+	    TxPrintf("\n");
+	    break;
+	case PROPERTY_TYPE_DIMENSION:
+	    TxPrintf("%s = ", name);
+	    for (i = 0; i < proprec->prop_len; i++)
+		TxPrintf("%s ", DBWPrintValue(proprec->prop_value.prop_integer[i],
+			w, ((i % 2) == 0) ? TRUE : FALSE));
+	    TxPrintf("\n");
+	    break;
+	case PROPERTY_TYPE_PLANE:
+    	    TxPrintf("%s = ", name);
+	    DBSrPaintArea((Tile *)NULL, proprec->prop_value.prop_plane,
+			&TiPlaneRect, &CIFSolidBits, printPlanePropFunc,
+			(ClientData)NULL);
+    	    TxPrintf("\n");
+	    break;
+	case PROPERTY_TYPE_DOUBLE:
+	    TxPrintf("%s = ", name);
+	    for (i = 0; i < proprec->prop_len; i++)
+		TxPrintf("%"DLONG_PREFIX"d ", proprec->prop_value.prop_double[i]);
+	    TxPrintf("\n");
+	    break;
+    }
 #endif
 
     return 0;	/* keep the search alive */

commands/CmdRS.c

@@ -99,7 +99,7 @@ CmdRandom(
 #ifdef MAGIC_WRAPPER
 	Tcl_SetObjResult(magicinterp, Tcl_NewIntObj(random()));
 #else
-	TxPrintf("%d", random());
+	TxPrintf("%ld", random());
 #endif
     }
     else if ((cmd->tx_argc >= 2) && (!strcmp(cmd->tx_argv[1], "seed")))
@@ -220,8 +220,6 @@ CmdSave(
     DBUpdateStamps(locDef);
     if (cmd->tx_argc == 2)
     {
-	char *fileName;
-
 	if (CmdIllegalChars(cmd->tx_argv[1], "[],", "Cell name"))
 	    return;
 
@@ -637,10 +635,21 @@ cmdSelectArea(
 	int i;
 	for (i = 0; i < DBNumUserLayers; i++)
 	{
-	    if((TTMaskHasType(&mask, i)) && !(TTMaskHasType(&crec->dbw_visibleLayers, i)))
+	    if ((TTMaskHasType(&mask, i)) &&
+			!(TTMaskHasType(&crec->dbw_visibleLayers, i)))
 		TTMaskClearType(&mask, i);
 	}
+
+	/* Remove L_CELL and L_LABEL if crec->dbw_flags indicates that
+	 * they are not visible in the layout window.
+	 */
+
+	if (!(crec->dbw_flags & DBW_SEELABELS)) TTMaskClearType(&mask, L_LABEL);
+	if (!(crec->dbw_flags & DBW_SEECELLS)) TTMaskClearType(&mask, L_CELL);
     }
+    else if (option == SEL_AREA)
+	TTMaskSetType(&mask, L_LABEL);
+
     SelectArea(&scx, &mask, crec->dbw_bitmask, globmatch);
 }
 
@@ -1029,7 +1038,7 @@ CmdSelect(
 
 	/*--------------------------------------------------------------------
 	 * Select everything under the box, perhaps looking only at
-	 * particular layers, but only if its visible.
+	 * particular layers, but only if it's visible.
 	 *--------------------------------------------------------------------
 	 */
 
@@ -1086,25 +1095,33 @@ CmdSelect(
 	 */
 
 	case SEL_BBOX:
+	{
+	    char *selllx, *sellly, *selurx, *selury;
+
 	    GeoTransRect(&SelectUse->cu_transform, &SelectDef->cd_bbox, &selarea);
 
+	    selllx = DBWPrintValue(selarea.r_xbot, w, TRUE);
+	    sellly = DBWPrintValue(selarea.r_ybot, w, FALSE);
+	    selurx = DBWPrintValue(selarea.r_xtop, w, TRUE);
+	    selury = DBWPrintValue(selarea.r_ytop, w, FALSE);
+
 #ifdef MAGIC_WRAPPER
 	    lobj = Tcl_NewListObj(0, NULL);
 	    Tcl_ListObjAppendElement(magicinterp, lobj,
-			Tcl_NewIntObj(selarea.r_xbot));
+			Tcl_NewStringObj(selllx, -1));
 	    Tcl_ListObjAppendElement(magicinterp, lobj,
-			Tcl_NewIntObj(selarea.r_ybot));
+			Tcl_NewStringObj(sellly, -1));
 	    Tcl_ListObjAppendElement(magicinterp, lobj,
-			Tcl_NewIntObj(selarea.r_xtop));
+			Tcl_NewStringObj(selurx, -1));
 	    Tcl_ListObjAppendElement(magicinterp, lobj,
-			Tcl_NewIntObj(selarea.r_ytop));
+			Tcl_NewStringObj(selury, -1));
 	    Tcl_SetObjResult(magicinterp, lobj);
 #else
-	    TxPrintf("Select bounding box: %d %d %d %d\n",
-		    selarea.r_xbot, selarea.r_ybot,
-		    selarea.r_xtop, selarea.r_ytop);
+	    TxPrintf("Select bounding box: %s %s %s %s\n",
+		    selllx, sellly, selurx, selury);
 #endif
 	    return;
+	}
 
 	/*--------------------------------------------------------------------
 	 * Make a copy of the selection at its present loction but do not
@@ -1121,14 +1138,36 @@ CmdSelect(
 
 	/*--------------------------------------------------------------------
 	 * Move the selection relative to the cell def
+	 * With two additional arguments:  Arguments are X and Y position
+	 * With no additional arugments:  X and Y position taken from pointer.
 	 *--------------------------------------------------------------------
 	 */
 
 	 case SEL_MOVE:
-	    if ((more) || (less) || (primargs != 4)) goto usageError;
+	    if ((more) || (less) || ((primargs != 4) && (primargs != 2)))
+		goto usageError;
 
-	    p.p_x = cmdParseCoord(w, cmd->tx_argv[2], FALSE, TRUE);
-	    p.p_y = cmdParseCoord(w, cmd->tx_argv[3], FALSE, FALSE);
+	    if (primargs == 2)
+	    {
+		MagWindow *window;
+		Rect rootBox;
+
+		window = ToolGetPoint(&p, (Rect *)NULL);
+		if ((window == NULL)  ||
+			!ToolGetBox(&SelectRootDef, &rootBox) ||
+			(EditRootDef != ((CellUse *) window->w_surfaceID)->cu_def))
+		{
+		    TxError("Error:  Pointer is not in the edit cell.\n");
+		    return;
+		}
+		p.p_x -= rootBox.r_xbot;
+		p.p_y -= rootBox.r_ybot;
+	    }
+	    else
+	    {
+		p.p_x = cmdParseCoord(w, cmd->tx_argv[2], FALSE, TRUE);
+		p.p_y = cmdParseCoord(w, cmd->tx_argv[3], FALSE, FALSE);
+	    }
 
 	    /* Erase first, then recompute the transform */
 	    GeoTransRect(&SelectUse->cu_transform, &SelectDef->cd_bbox, &selarea);
@@ -1236,15 +1275,17 @@ CmdSelect(
 	    /* of rlist)						*/
 	    SelectClear();
 
+	    free_magic1_t mm1 = freeMagic1_init();
 	    while (rlist != NULL)
 	    {
 		/* Paint rlist back into SelectDef */
 		DBPaint(SelectDef, &rlist->r_r, rlist->r_type);
 
 		/* cleanup as we go */
-		freeMagic(rlist);
+		freeMagic1(&mm1, rlist);
 		rlist = rlist->r_next;
 	    }
+	    freeMagic1_end(&mm1);
 
 	    /* Force erase and redraw of the selection */
 	    DBReComputeBbox(SelectDef);
@@ -1771,13 +1812,18 @@ cmdLabelSizeFunc(
 
     if (value == NULL)
     {
+	char *labsize;
+	MagWindow *w;
+
+	windCheckOnlyWindow(&w, DBWclientID);
+	labsize = DBWPrintValue(label->lab_size / 8, w, FALSE);
+
 #ifdef MAGIC_WRAPPER
 	lobj = Tcl_GetObjResult(magicinterp);
-	Tcl_ListObjAppendElement(magicinterp, lobj,
-			Tcl_NewDoubleObj((double)label->lab_size / 8.0));
+	Tcl_ListObjAppendElement(magicinterp, lobj, Tcl_NewStringObj(labsize, -1));
 	Tcl_SetObjResult(magicinterp, lobj);
 #else
-	TxPrintf("%g\n", (double)label->lab_size / 8.0);
+	TxPrintf("%s\n", labsize);
 #endif
     }
     else if (label->lab_size != *value)
@@ -1922,18 +1968,22 @@ cmdLabelOffsetFunc(
 
     if (point == NULL)
     {
+	char *laboffx, *laboffy;
+	MagWindow *w;
+
+	windCheckOnlyWindow(&w, DBWclientID);
+	laboffx = DBWPrintValue(label->lab_offset.p_x / 8, w, TRUE);
+	laboffy = DBWPrintValue(label->lab_offset.p_x / 8, w, FALSE);
+
 #ifdef MAGIC_WRAPPER
 	lobj = Tcl_GetObjResult(magicinterp);
 	pobj = Tcl_NewListObj(0, NULL);
 	Tcl_ListObjAppendElement(magicinterp, lobj, pobj);
-	Tcl_ListObjAppendElement(magicinterp, pobj,
-			Tcl_NewDoubleObj((double)label->lab_offset.p_x / 8.0));
-	Tcl_ListObjAppendElement(magicinterp, pobj,
-			Tcl_NewDoubleObj((double)label->lab_offset.p_y / 8.0));
+	Tcl_ListObjAppendElement(magicinterp, pobj, Tcl_NewStringObj(laboffx, -1));
+	Tcl_ListObjAppendElement(magicinterp, pobj, Tcl_NewStringObj(laboffy, -1));
 	Tcl_SetObjResult(magicinterp, lobj);
 #else
-	TxPrintf("%g %g\n", (double)(label->lab_offset.p_x) / 8.0,
-		(double)(label->lab_offset.p_y) / 8.0);
+	TxPrintf("%s %s\n", laboffx, laboffy);
 #endif
     }
     else if (!GEO_SAMEPOINT(label->lab_offset, *point))
@@ -1963,23 +2013,25 @@ cmdLabelRectFunc(
 
     if (rect == NULL)
     {
+	char *labllx, *lablly, *laburx, *labury;
+
+	/* Note:  Ideally, the MagWindow pointer should be passed to this function */
+	labllx = DBWPrintValue(label->lab_rect.r_xbot, (MagWindow *)NULL, TRUE);
+	lablly = DBWPrintValue(label->lab_rect.r_ybot, (MagWindow *)NULL, FALSE);
+	laburx = DBWPrintValue(label->lab_rect.r_xtop, (MagWindow *)NULL, TRUE);
+	labury = DBWPrintValue(label->lab_rect.r_ytop, (MagWindow *)NULL, FALSE);
+
 #ifdef MAGIC_WRAPPER
 	lobj = Tcl_GetObjResult(magicinterp);
 	pobj = Tcl_NewListObj(0, NULL);
 	Tcl_ListObjAppendElement(magicinterp, lobj, pobj);
-	Tcl_ListObjAppendElement(magicinterp, pobj,
-			Tcl_NewIntObj((double)label->lab_rect.r_xbot));
-	Tcl_ListObjAppendElement(magicinterp, pobj,
-			Tcl_NewIntObj((double)label->lab_rect.r_ybot));
-	Tcl_ListObjAppendElement(magicinterp, pobj,
-			Tcl_NewIntObj((double)label->lab_rect.r_xtop));
-	Tcl_ListObjAppendElement(magicinterp, pobj,
-			Tcl_NewIntObj((double)label->lab_rect.r_ytop));
+	Tcl_ListObjAppendElement(magicinterp, pobj, Tcl_NewStringObj(labllx, -1));
+	Tcl_ListObjAppendElement(magicinterp, pobj, Tcl_NewStringObj(lablly, -1));
+	Tcl_ListObjAppendElement(magicinterp, pobj, Tcl_NewStringObj(laburx, -1));
+	Tcl_ListObjAppendElement(magicinterp, pobj, Tcl_NewStringObj(labury, -1));
 	Tcl_SetObjResult(magicinterp, lobj);
 #else
-	TxPrintf("%d %d %d %d\n",
-			label->lab_rect.r_xbot, label->lab_rect.r_ybot,
-			label->lab_rect.r_xtop, label->lab_rect.r_ytop);
+	TxPrintf("%s %s %s %s\n", labllx, lablly, laburx,labury);
 #endif
     }
     else if (!GEO_SAMERECT(label->lab_rect, *rect))
@@ -2180,9 +2232,13 @@ CmdSetLabel(
 	    }
 	    else if (EditCellUse)
 	    {
-		SelEnumLabelsMirror(&DBAllTypeBits, TRUE, (bool *)NULL,
-			cmdLabelTextFunc, (locargc == 3) ?
-			(ClientData)cmd->tx_argv[argstart + 1] : (ClientData)NULL);
+		if (locargc == 2)
+		    SelEnumLabels(&DBAllTypeBits, TRUE, (bool *)NULL,
+				cmdLabelTextFunc, (ClientData)NULL);
+		else
+		    SelEnumLabelsMirror(&DBAllTypeBits, TRUE, (bool *)NULL,
+				cmdLabelTextFunc,
+				(ClientData)cmd->tx_argv[argstart + 1]);
 	    }
 	    break;
 
@@ -2248,9 +2304,12 @@ CmdSetLabel(
 		}
 		else if (EditCellUse)
 		{
-		    SelEnumLabelsMirror(&DBAllTypeBits, TRUE, (bool *)NULL,
-				cmdLabelFontFunc, (locargc == 3) ?
-				(ClientData)&font : (ClientData)NULL);
+		    if (locargc == 2)
+			SelEnumLabels(&DBAllTypeBits, TRUE, (bool *)NULL,
+				cmdLabelFontFunc, (ClientData)NULL);
+		    else
+			SelEnumLabelsMirror(&DBAllTypeBits, TRUE, (bool *)NULL,
+				cmdLabelFontFunc, (ClientData)&font);
 		}
 	    }
 	    break;
@@ -2278,9 +2337,12 @@ CmdSetLabel(
 	    }
 	    else if (EditCellUse)
 	    {
-		SelEnumLabelsMirror(&DBAllTypeBits, TRUE, (bool *)NULL,
-			cmdLabelJustFunc, (locargc == 3) ?
-			(ClientData)&pos : (ClientData)NULL);
+		if (locargc == 2)
+		    SelEnumLabels(&DBAllTypeBits, TRUE, (bool *)NULL,
+				cmdLabelJustFunc, (ClientData)NULL);
+		else
+		    SelEnumLabelsMirror(&DBAllTypeBits, TRUE, (bool *)NULL,
+				cmdLabelJustFunc, (ClientData)&pos);
 	    }
 	    break;
 
@@ -2295,11 +2357,13 @@ CmdSetLabel(
 	    {
 		if (locargc == 2)
 		{
+		    char *labsize;
+
+		    labsize = DBWPrintValue(DefaultLabel->lab_size, w, FALSE);
 #ifdef MAGIC_WRAPPER
-		    Tcl_SetObjResult(magicinterp,
-				Tcl_NewIntObj(DefaultLabel->lab_size));
+		    Tcl_SetObjResult(magicinterp, Tcl_NewStringObj(labsize, -1));
 #else
-		    TxPrintf("%d\n", DefaultLabel->lab_size);
+		    TxPrintf("%s\n", labsize);
 #endif
 		}
 		else
@@ -2307,9 +2371,12 @@ CmdSetLabel(
 	    }
 	    else if (EditCellUse)
 	    {
-		SelEnumLabelsMirror(&DBAllTypeBits, TRUE, (bool *)NULL,
-			cmdLabelSizeFunc, (locargc == 3) ?
-			(ClientData)&size : (ClientData)NULL);
+		if (locargc == 2)
+		    SelEnumLabels(&DBAllTypeBits, TRUE, (bool *)NULL,
+				cmdLabelSizeFunc, (ClientData)NULL);
+		else
+		    SelEnumLabelsMirror(&DBAllTypeBits, TRUE, (bool *)NULL,
+				cmdLabelSizeFunc, (ClientData)&size);
 	    }
 	    break;
 
@@ -2338,16 +2405,20 @@ CmdSetLabel(
 	    {
 		if (locargc == 2)
 		{
+		    char *laboffx, *laboffy;
+		    laboffx = DBWPrintValue(DefaultLabel->lab_offset.p_x, w,
+					TRUE);
+		    laboffy = DBWPrintValue(DefaultLabel->lab_offset.p_y, w,
+					FALSE);
 #ifdef MAGIC_WRAPPER
 		    lobj = Tcl_NewListObj(0, NULL);
 	    	    Tcl_ListObjAppendElement(magicinterp, lobj,
-				Tcl_NewIntObj(DefaultLabel->lab_offset.p_x));
+				Tcl_NewStringObj(laboffx, -1));
 	    	    Tcl_ListObjAppendElement(magicinterp, lobj,
-				Tcl_NewIntObj(DefaultLabel->lab_offset.p_y));
+				Tcl_NewStringObj(laboffy, -1));
 		    Tcl_SetObjResult(magicinterp, lobj);
 #else
-		    TxPrintf("%d %d\n", DefaultLabel->lab_offset.p_x,
-				DefaultLabel->lab_offset.p_y);
+		    TxPrintf("%s %s\n", laboffx, laboffy);
 #endif
 		}
 		else
@@ -2355,9 +2426,12 @@ CmdSetLabel(
 	    }
 	    else if (EditCellUse)
 	    {
-		SelEnumLabelsMirror(&DBAllTypeBits, TRUE, (bool *)NULL,
-			cmdLabelOffsetFunc, (locargc != 2) ?
-			(ClientData)&offset : (ClientData)NULL);
+		if (locargc == 2)
+		    SelEnumLabels(&DBAllTypeBits, TRUE, (bool *)NULL,
+				cmdLabelOffsetFunc, (ClientData)NULL);
+		else
+		    SelEnumLabelsMirror(&DBAllTypeBits, TRUE, (bool *)NULL,
+				cmdLabelOffsetFunc, (ClientData)&offset);
 	    }
 	    break;
 
@@ -2421,10 +2495,12 @@ CmdSetLabel(
 		    rect.r_ytop = cmdScaleCoord(w, cmd->tx_argv[argstart + 4],
 				TRUE, FALSE, 1);
 		}
-		SelEnumLabelsMirror(&DBAllTypeBits, TRUE, (bool *)NULL,
-				cmdLabelRectFunc,
-				((locargc == 6) || (locargc == 3)) ?
-				(ClientData)&rect : (ClientData)NULL);
+		if ((locargc == 3) || (locargc == 6))
+		    SelEnumLabelsMirror(&DBAllTypeBits, TRUE, (bool *)NULL,
+				cmdLabelRectFunc, (ClientData)&rect);
+		else
+		    SelEnumLabels(&DBAllTypeBits, TRUE, (bool *)NULL,
+				cmdLabelRectFunc, (ClientData)NULL);
 	    }
 	    break;
 
@@ -2450,9 +2526,12 @@ CmdSetLabel(
 	    }
 	    else if (EditCellUse)
 	    {
-		SelEnumLabelsMirror(&DBAllTypeBits, TRUE, (bool *)NULL,
-			cmdLabelRotateFunc, (locargc == 3) ?
-			(ClientData)&rotate : (ClientData)NULL);
+		if (locargc == 2)
+		    SelEnumLabels(&DBAllTypeBits, TRUE, (bool *)NULL,
+				cmdLabelRotateFunc, (ClientData)NULL);
+		else
+		    SelEnumLabelsMirror(&DBAllTypeBits, TRUE, (bool *)NULL,
+				cmdLabelRotateFunc, (ClientData)&rotate);
 	    }
 	    break;
 
@@ -2484,9 +2563,12 @@ CmdSetLabel(
 	    }
 	    else if (EditCellUse)
 	    {
-		SelEnumLabels(&DBAllTypeBits, TRUE, (bool *)NULL,
-			cmdLabelStickyFunc, (locargc == 3) ?
-			(ClientData)&flags : (ClientData)NULL);
+		if (locargc == 2)
+		    SelEnumLabels(&DBAllTypeBits, TRUE, (bool *)NULL,
+				cmdLabelStickyFunc, (ClientData)NULL);
+		else
+		    SelEnumLabelsMirror(&DBAllTypeBits, TRUE, (bool *)NULL,
+				cmdLabelStickyFunc, (ClientData)&flags);
 	    }
 	    break;
 
@@ -2514,7 +2596,7 @@ CmdSetLabel(
 		    else
 #ifdef MAGIC_WRAPPER
 		        Tcl_SetResult(magicinterp,
-				DBTypeLongNameTbl[DefaultLabel->lab_type],
+				(char*)DBTypeLongNameTbl[DefaultLabel->lab_type], /* Tcl treats as const */
 				TCL_VOLATILE);
 #else
 		    	TxPrintf("%s\n", DBTypeLongNameTbl[DefaultLabel->lab_type]);
@@ -2525,9 +2607,12 @@ CmdSetLabel(
 	    }
 	    else if (EditCellUse)
 	    {
-		SelEnumLabels(&DBAllTypeBits, TRUE, (bool *)NULL,
-			cmdLabelLayerFunc, (locargc == 3) ?
-			(ClientData)&ttype : (ClientData)NULL);
+		if (locargc == 2)
+		    SelEnumLabels(&DBAllTypeBits, TRUE, (bool *)NULL,
+				cmdLabelLayerFunc, (ClientData)NULL);
+		else
+		    SelEnumLabelsMirror(&DBAllTypeBits, TRUE, (bool *)NULL,
+				cmdLabelLayerFunc, (ClientData)&ttype);
 	    }
 	    break;
 
@@ -2764,7 +2849,7 @@ CmdSimCmd(
 {
     static char cmdbuf[200];
     char 	*strptr;
-    char 	*nodeCmd;
+    const char 	*nodeCmd;
     int 	i;
 
     if (!SimRsimRunning) {
@@ -2862,16 +2947,39 @@ CmdSnap(
 	TxPrintf("Usage: snap [internal | lambda | user]\n");
 	return;
     }
+
+    /* Backwards compatibility:  Use of "snap" to set units display and
+     * parsing has been deprecated as of February 2026.  However, as this
+     * is rather disruptive to existing scripts which use "snap" to change
+     * the parsing of units, then the following measure is being taken
+     * (for now, anyway):  If DBWUnits is set to DBW_UNITS_DEFAULT, then
+     * "snap internal" will set DBWUnits as well as DBWSnapToGrid.  If
+     * DBWUnits is changed first (e.g., "units internal"), then "snap" will
+     * affect only the snap grid.  The older usage will be accompanied by a
+     * warning message.  Note that backwards compatibility is being kept
+     * only in the case of "snap internal", which was commonly used in
+     * scripts to make sure that all units were interpreted as internal
+     * units.
+     */
+    if ((DBWUnits == DBW_UNITS_DEFAULT) && (n == SNAP_INTERNAL))
+    {
+	DBWUnits = DBW_UNITS_INTERNAL;
+	TxError("Warning:  snap setting is also changing units.  This usage "
+		"is deprecated\nand may be removed in the future.  Use "
+		"\"units\" to change units, and\nchange units before "
+		"setting snap to keep this message from appearing.\n");
+    }
+
     switch (n)
     {
 	case SNAP_OFF: case SNAP_INTERNAL:
-	    DBWSnapToGrid = DBW_SNAP_INTERNAL;
+	    DBWSnapToGrid = DBW_UNITS_INTERNAL;
 	    return;
 	case SNAP_LAMBDA:
-	    DBWSnapToGrid = DBW_SNAP_LAMBDA;
+	    DBWSnapToGrid = DBW_UNITS_LAMBDA;
 	    return;
 	case SNAP_GRID: case SNAP_USER: case SNAP_ON:
-	    DBWSnapToGrid = DBW_SNAP_USER;
+	    DBWSnapToGrid = DBW_UNITS_USER;
 	    return;
     }
 
@@ -2879,21 +2987,19 @@ printit:
     if (n == SNAP_LIST)  /* list */
 #ifdef MAGIC_WRAPPER
 	Tcl_SetResult(magicinterp,
-		(DBWSnapToGrid == DBW_SNAP_INTERNAL) ? "internal" :
-		((DBWSnapToGrid == DBW_SNAP_LAMBDA) ? "lambda" : "user"),
+		(DBWSnapToGrid == DBW_UNITS_INTERNAL) ? "internal" :
+		((DBWSnapToGrid == DBW_UNITS_LAMBDA) ? "lambda" : "user"),
 		TCL_VOLATILE);
 #else
-	TxPrintf("%s\n", (DBWSnapToGrid == DBW_SNAP_INTERNAL) ? "internal" :
-		((DBWSnapToGrid == DBW_SNAP_LAMBDA) ? "lambda" : "user"));
+	TxPrintf("%s\n", (DBWSnapToGrid == DBW_UNITS_INTERNAL) ? "internal" :
+		((DBWSnapToGrid == DBW_UNITS_LAMBDA) ? "lambda" : "user"));
 #endif
     else
 	TxPrintf("Box is aligned to %s grid\n",
-		(DBWSnapToGrid == DBW_SNAP_INTERNAL) ? "internal" :
-		((DBWSnapToGrid == DBW_SNAP_LAMBDA) ? "lambda" : "user"));
+		(DBWSnapToGrid == DBW_UNITS_INTERNAL) ? "internal" :
+		((DBWSnapToGrid == DBW_UNITS_LAMBDA) ? "lambda" : "user"));
 }
 
-
-
 /*
  * ----------------------------------------------------------------------------
  *

commands/CmdSubrs.c

@@ -73,9 +73,22 @@ TileTypeBitMask CmdYMAllButSpace;
  * lambda, a suffix of "g" indicates the user grid, and a suffix in metric
  * notation ("nm", "um", "mm", "cm") indicates natural units.  Other valid
  * units are "cu" or "centimicrons" for centimicrons, or "microns" for um.
- *    Units without any suffix are assumed to be in lambda if "snap"
- * (DBWSnapToGrid) is set to lambda, grid units if "snap" is set to the
- * user grid, and internal units otherwise.
+ *    Traditional (backwards-compatible) behavior:  Units without any suffix
+ * are assumed to be in lambda if "snap" (DBWSnapToGrid) is set to lambda,
+ * grid units if "snap" is set to the user grid, and internal units otherwise.
+ *    Current behavior:  Use of the "units" command to set the units to
+ * any value other than "default" causes cmdScaleCoord() to parse any
+ * units provided without an identifying suffix as the units indicted by
+ * the "units" command.  Once the "units" command has been issued, the
+ * values are dependent on DBWUnits and not on DBWSnapToGrid.
+ *
+ *    Additional behavior from magic version 8.3.596:  A single command
+ * option can use simple expressions using '+', '-', '*', and '/'.  These
+ * can be passed as a single token, without spaces, or within a string
+ * token deliniated by quotes or braces, per usual Tcl syntax.  Unlike
+ * the Tcl "expr" command, this can solve arithmetic expressions of
+ * suffixed values, evaluated independently such that different suffixes
+ * may be used (e.g., "1g + 3um" meaning 1 grid pitch plus 3 microns).
  *
  *    MagWindow argument w is used only with grid-based snapping, to find
  * the value of the grid for the given window.  In this case, because the
@@ -99,6 +112,13 @@ TileTypeBitMask CmdYMAllButSpace;
  * ----------------------------------------------------------------------------
  */
 
+#define PARSEOP_NONE	0
+#define PARSEOP_ADD	1
+#define PARSEOP_SUB	2
+#define PARSEOP_MUL	3
+#define PARSEOP_DIV	4
+#define PARSEOP_END	5
+
 int
 cmdScaleCoord(
     MagWindow *w,
@@ -109,107 +129,195 @@ cmdScaleCoord(
 {
     char *endptr;
     double dval = 0;
-    int mscale = 1;
+    int mscale = 1, curunits;
+    int retval, curval, parseop;
     DBWclientRec *crec;
 
-    if (*arg == '{') arg++;
-    while (isspace(*arg)) arg++;
+    if (*arg == '{' || *arg == '"') arg++;
+    while (isspace(*arg) && (*arg != '\0')) arg++;
 
-    dval = strtod(arg, &endptr);
-    dval *= (double)scale;
+    parseop = PARSEOP_NONE;
+    retval = 0;
+    while (*arg != '\0')
+    {
+	dval = strtod(arg, &endptr);
+	dval *= (double)scale;
+	mscale = -1;
 
-    if (endptr == arg)
-    {
-        /* strtod() error condition */
-	TxError("Coordinate value cannot be parsed:  assuming 0\n");
-	return 0;
-    }
-
-    else if ((*endptr == 'l')
-		|| ((*endptr == '\0') && (DBWSnapToGrid == DBW_SNAP_LAMBDA)))
-    {
-	/* lambda or default units */
-	dval *= (double)DBLambda[1];
-	dval /= (double)DBLambda[0];
-	return round(dval);
-    }
-    else if ((*endptr == 'i')
-		|| ((*endptr == '\0') && (DBWSnapToGrid == DBW_SNAP_INTERNAL)))
-    {
-	/* internal units */
-	return round(dval);
-    }
-    else if ((*endptr == 'g')
-		|| ((*endptr == '\0') && (DBWSnapToGrid == DBW_SNAP_USER)))
-    {
-	/* grid units */
-	if (w == (MagWindow *)NULL)
+	if (endptr == arg)
 	{
-	    windCheckOnlyWindow(&w, DBWclientID);
-	    if (w == (MagWindow *)NULL)
-		return round(dval);		/* Default, if window is unknown */
-	}
-	crec = (DBWclientRec *) w->w_clientData;
-	if (is_x)
-	{
-	    dval *= (double)(crec->dbw_gridRect.r_xtop
-			- crec->dbw_gridRect.r_xbot);
-	    if (!is_relative)
-		dval += (double)crec->dbw_gridRect.r_xbot;
+	    /* strtod() error condition */
+ 	    TxError("Coordinate value cannot be parsed:  assuming 0\n");
+	    curval = 0;
+	    break;
 	}
+
+	/* Original behavior was to accept un-suffixed values according to the
+	 * "snap" setting.  This behavior remains in effect until the "units"
+	 * command is used, in which case units follow the selected units
+	 * value indepedendently of the snap setting.
+	 *
+	 * Updated 12/24/2026 to handle space-separated values (in which
+	 * *endptr may be a space as well as NULL).
+	 */
+	if (DBWUnits == DBW_UNITS_DEFAULT)
+	    curunits = DBWSnapToGrid;
 	else
+	    curunits = DBWUnits & DBW_UNITS_TYPE_MASK;
+
+	if ((*endptr == 'l')
+		|| (((*endptr == '\0') || isspace(*endptr))
+		&& (curunits == DBW_UNITS_LAMBDA)))
 	{
-	    dval *= (double)(crec->dbw_gridRect.r_ytop
-			- crec->dbw_gridRect.r_ybot);
-	    if (!is_relative)
-		dval += (double)crec->dbw_gridRect.r_ybot;
+	    /* lambda or default units */
+	    dval *= (double)DBLambda[1];
+	    dval /= (double)DBLambda[0];
 	}
-	return round(dval);
-    }
-    else
-    {
-        /* natural units referred to the current cifoutput style */
-	if (*(endptr + 1) == 'm')
+	else if ((*endptr == 'i')
+		|| (((*endptr == '\0') || isspace(*endptr))
+		&& (curunits == DBW_UNITS_INTERNAL)))
+	{
+	    /* internal units */
+	}
+	else if ((*endptr == 'g')
+		|| (((*endptr == '\0') || isspace(*endptr))
+		&& (curunits == DBW_UNITS_USER)))
+	{
+	    /* grid units */
+	    if (w == (MagWindow *)NULL)
+	    {
+		windCheckOnlyWindow(&w, DBWclientID);
+		if (w == (MagWindow *)NULL)
+		{
+		    curval = round(dval);	/* Default, if window is unknown */
+		    break;
+		}
+	    }
+	    crec = (DBWclientRec *) w->w_clientData;
+	    if (is_x)
+	    {
+		dval *= (double)(crec->dbw_gridRect.r_xtop
+			- crec->dbw_gridRect.r_xbot);
+		if (!is_relative)
+		    dval += (double)crec->dbw_gridRect.r_xbot;
+	    }
+	    else
+	    {
+		dval *= (double)(crec->dbw_gridRect.r_ytop
+			- crec->dbw_gridRect.r_ybot);
+		if (!is_relative)
+		    dval += (double)crec->dbw_gridRect.r_ybot;
+	    }
+	}
+	else if (((*endptr == '\0') || isspace(*endptr))
+		&& (curunits == DBW_UNITS_MICRONS))
+	{
+	    mscale = 1000;
+	}
+	else if (*endptr != '\0')
+	{
+	    /* natural units referred to the current cifoutput style */
+	    if (*(endptr + 1) == 'm')
+	    {
+		switch (*endptr)
+		{
+		    case 'n':
+			mscale = 1;
+			break;
+		    case 'u':
+			mscale = 1000;
+			break;
+		    case 'm':
+			mscale = 1000000;
+			break;
+		    case 'c':
+			mscale = 10000000;
+			break;
+		    default:
+			TxError("Unknown metric prefix \"%cm\"; assuming "
+				"internal units\n", *endptr);
+			mscale = -1;
+		}
+	    }
+	    else if ((*endptr == 'u') && !isalnum(*(endptr + 1)))
+		/* Maybe "u" is too ambiguous but it is very commonly used as
+		 * an abbreviation for "micron".
+		 */
+		mscale = 1000;
+	    else if (!strncmp(endptr, "micron", 6))
+		mscale = 1000;
+	    else if (!strncmp(endptr, "centimicron", 11) || !strcmp(endptr, "cu"))
+		mscale = 10;
+	    else if (!isspace(*endptr) && (*endptr != '+') && (*endptr != '-') &&
+			(*endptr != '*') && (*endptr != '/'))
+	    {
+		TxError("Unknown coordinate type at \"%s\"; assuming internal units\n",
+			endptr);
+		mscale = -1;
+	    }
+	}
+	if (mscale != -1)
+	    dval /= CIFGetOutputScale(mscale);
+	curval = round(dval);
+
+	switch (parseop)
+	{
+	    case PARSEOP_NONE:
+		retval = curval;
+		break;
+	    case PARSEOP_ADD:
+		retval += curval;
+		break;
+	    case PARSEOP_SUB:
+		retval -= curval;
+		break;
+	    case PARSEOP_MUL:
+		retval *= curval;
+		break;
+	    case PARSEOP_DIV:
+		retval /= curval;
+		break;
+	}
+
+	parseop = PARSEOP_NONE;
+	while (*endptr != '\0')
 	{
 	    switch (*endptr)
 	    {
-		case 'n':
-		    mscale = 1;
+		case '}':
+		case '"':
+		    parseop = PARSEOP_END;
 		    break;
-		case 'u':
-		    mscale = 1000;
+		case '+':
+		    parseop = PARSEOP_ADD;
+		    endptr++;
 		    break;
-		case 'm':
-		    mscale = 1000000;
+		case '-':
+		    parseop = PARSEOP_SUB;
+		    endptr++;
 		    break;
-		case 'c':
-		    mscale = 10000000;
+		case '*':
+		    parseop = PARSEOP_MUL;
+		    endptr++;
+		    break;
+		case '/':
+		    parseop = PARSEOP_DIV;
+		    endptr++;
+		    break;
+		case ' ':
+		case '\t':
+		    endptr++;
 		    break;
 		default:
-		    TxError("Unknown metric prefix \"%cm\"; assuming internal units\n",
-				*endptr);
-		    return round(dval);
+		    /* Should this flag an error? */
+		    return retval;
 	    }
+	    if (parseop != PARSEOP_NONE) break;
 	}
-	else if (!strcmp(endptr, "u"))
-	    /* Maybe "u" is too ambiguous but it is very commonly used as
-	     * an abbreviation for "micron".
-	     */
-	    mscale = 1000;
-	else if (!strncmp(endptr, "micron", 6))
-	    mscale = 1000;
-	else if (!strncmp(endptr, "centimicron", 11) || !strcmp(endptr, "cu"))
-	    mscale = 10;
-	else if (!isspace(*endptr))
-	{
-	    TxError("Unknown coordinate type \"%s\"; assuming internal units\n",
-			endptr);
-	    return round(dval);
-	}
+	arg = endptr;
+	while (isspace(*arg) && (*arg != '\0')) arg++;
     }
-    if (!isspace(*endptr))
-        dval /= CIFGetOutputScale(mscale);
-    return round(dval);
+    return retval;
 }
 
 /*
@@ -653,13 +761,16 @@ cmdSaveCell(
     if (!tryRename || (fileName == NULL) || (strcmp(cellDef->cd_name, fileName) == 0))
 	goto cleanup;
 
-    /* Rename the cell */
-    if (!DBCellRenameDef(cellDef, fileName))
+    /* Rename the cell, unless fileName is a .tcl file (scripted output) */
+    if ((strlen(fileName) <= 4) || strcmp(fileName + strlen(fileName) - 4, ".tcl"))
     {
-	/* This should never happen */
-	TxError("Magic error: there is already a cell named \"%s\"\n",
+	if (!DBCellRenameDef(cellDef, fileName))
+	{
+	    /* This should never happen */
+	    TxError("Magic error: there is already a cell named \"%s\"\n",
 		    fileName);
-	goto cleanup;
+	    goto cleanup;
+	}
     }
 
     if (EditCellUse && (cellDef == EditCellUse->cu_def))
@@ -908,7 +1019,7 @@ CmdSetWindCaption(
 				 * edit cell was selected.
 				 */
 {
-    int cmdWindSet(MagWindow *window);
+    int cmdWindSet(MagWindow *window, ClientData clientData);	/* UNUSED */
 
     newEditDef = (newEditUse) ? newEditUse->cu_def : NULL;
     newRootDef = rootDef;
@@ -942,9 +1053,11 @@ CmdSetWindCaption(
  * ----------------------------------------------------------------------------
  */
 
+/*ARGSUSED*/
 int
 cmdWindSet(
-    MagWindow *window)
+    MagWindow *window,
+    ClientData clientData)	/* UNUSED */
 {
     char caption[200];
     CellDef *wDef;
@@ -1128,7 +1241,7 @@ cmdExpandOneLevel(
     extern int cmdExpand1func(CellUse *cu, ClientData bitmask);
 
     /* first, expand this cell use */
-    DBExpand(cu, bitmask, expand);
+    DBExpand(cu, bitmask, expand ? DB_EXPAND : DB_UNEXPAND);
 
     /* now, unexpand its direct children (ONE LEVEL ONLY) */
     if (expand)
@@ -1140,7 +1253,7 @@ cmdExpand1func(
     CellUse *cu,
     ClientData bitmask)
 {
-    DBExpand(cu, (int)CD2INT(bitmask), FALSE);
+    DBExpand(cu, (int)CD2INT(bitmask), DB_UNEXPAND);
     return 0;
 }
 
@@ -1196,6 +1309,17 @@ cmdGetSelFunc(
     return 1;			/* Skip any other selected cells. */
 }
 
+
+/* The Open Group, Sep 2006, Austin/317 deprecated isascii(),
+ *  Apparently it cannot be used portably in a localized application.
+ */
+static int
+magic_isascii(int c)
+{
+    return (c & ~0x7f) == 0;
+}
+
+
 /*
  * ----------------------------------------------------------------------------
  *
@@ -1228,7 +1352,7 @@ CmdIllegalChars(
 
     for (p = string; *p != 0; p++)
     {
-	if (!isascii(*p)) goto error;
+	if (!magic_isascii(*p)) goto error;
 	if (iscntrl(*p)) goto error;
 	for (bad = illegal; *bad != 0; bad++)
 	{
@@ -1237,7 +1361,7 @@ CmdIllegalChars(
 	continue;
 
 	error:
-	if (!isascii(*p) || iscntrl(*p))
+	if (!magic_isascii(*p) || iscntrl(*p))
 	{
 	    TxError("%s contains illegal control character 0x%x\n",
 		   msg, *p);

commands/CmdTZ.c

@@ -61,7 +61,9 @@ static const char rcsid[] __attribute__ ((unused)) = "$Header: /usr/cvsroot/magi
 
 int
 existFunc(
-    Tile *tile)
+    Tile *tile,			/* (unused) */
+    TileType dinfo,		/* (unused) */
+    ClientData clientdata)	/* (unused) */
 {
     return 1;
 }
@@ -453,15 +455,18 @@ CmdTech(
 		}
 		if (!strncmp(cmd->tx_argv[2], "width", 5))
 		{
+		    char *techwidth;
 		    tresult = DRCGetDefaultLayerWidth(t1);
+		    techwidth = DBWPrintValue(tresult, w, TRUE);
 #ifdef MAGIC_WRAPPER
-		    Tcl_SetObjResult(magicinterp, Tcl_NewIntObj(tresult));
+		    Tcl_SetObjResult(magicinterp, Tcl_NewStringObj(techwidth, -1));
 #else
-		    TxPrintf("Minimum width is %d\n", tresult);
+		    TxPrintf("Minimum width is %s\n", techwidth);
 #endif
 		}
 		else if (!strncmp(cmd->tx_argv[2], "spac", 4))
 		{
+		    char *techspace;
 		    if (cmd->tx_argc >= 5)
 		    {
 			t2 = DBTechNoisyNameType(cmd->tx_argv[4]);
@@ -473,14 +478,16 @@ CmdTech(
 		    else
 			t2 = t1;
 		    tresult = DRCGetDefaultLayerSpacing(t1, t2);
+		    techspace = DBWPrintValue(tresult, w, TRUE);
 #ifdef MAGIC_WRAPPER
-		    Tcl_SetObjResult(magicinterp, Tcl_NewIntObj(tresult));
+		    Tcl_SetObjResult(magicinterp, Tcl_NewStringObj(techspace, -1));
 #else
-		    TxPrintf("Minimum spacing is %d\n", tresult);
+		    TxPrintf("Minimum spacing is %s\n", techspace);
 #endif
 		}
 		else if (!strncmp(cmd->tx_argv[2], "surr", 4))
 		{
+		    char *techsurround;
 		    if (cmd->tx_argc >= 5)
 		    {
 			t2 = DBTechNoisyNameType(cmd->tx_argv[4]);
@@ -496,14 +503,17 @@ CmdTech(
 		    }
 
 		    tresult = DRCGetDefaultLayerSurround(t1, t2);
+		    techsurround = DBWPrintValue(tresult, w, TRUE);
 #ifdef MAGIC_WRAPPER
-		    Tcl_SetObjResult(magicinterp, Tcl_NewIntObj(tresult));
+		    Tcl_SetObjResult(magicinterp, Tcl_NewStringObj(techsurround, -1));
 #else
-		    TxPrintf("Minimum surround is %d\n", tresult);
+		    TxPrintf("Minimum surround is %s\n", techsurround);
 #endif
 		}
 		else if (!strncmp(cmd->tx_argv[2], "direc", 5))
 		{
+		    char *techdirec;
+
 		    if (cmd->tx_argc >= 5)
 		    {
 			t2 = DBTechNoisyNameType(cmd->tx_argv[4]);
@@ -519,10 +529,11 @@ CmdTech(
 		    }
 
 		    tresult = DRCGetDirectionalLayerSurround(t1, t2);
+		    techdirec = DBWPrintValue(tresult, w, TRUE);
 #ifdef MAGIC_WRAPPER
-		    Tcl_SetObjResult(magicinterp, Tcl_NewIntObj(tresult));
+		    Tcl_SetObjResult(magicinterp, Tcl_NewStringObj(techdirec, -1));
 #else
-		    TxPrintf("Minimum surround (in one orientation) is %d\n", tresult);
+		    TxPrintf("Minimum surround (in one orientation) is %s\n", techdirec);
 #endif
 		}
 	    }
@@ -671,6 +682,15 @@ CmdTool(
 
     if (strcmp(cmd->tx_argv[1], "info") == 0)
 	DBWPrintButtonDoc();
+    else if (strcmp(cmd->tx_argv[1], "type") == 0)
+    {
+	char *toolType = DBWGetButtonHandler();
+#ifdef MAGIC_WRAPPER
+	Tcl_SetObjResult(magicinterp, Tcl_NewStringObj(toolType, -1));
+#else
+	TxPrintf("Current tool is \"%s\".\n", toolType);
+#endif /* MAGIC_WRAPPER */
+    }
     else (void) DBWChangeButtonHandler(cmd->tx_argv[1]);
 }
 
@@ -682,32 +702,62 @@ CmdTool(
  * Implement the "unexpand" command.
  *
  * Usage:
- *	unexpand
+ *	unexpand [selection|surround|overlap|all]
+ *
+ *	"selection" unexpands (hides) cells in the selection.  All
+ *	other options unexpand cells in the layout.  "all" unexpands
+ *	all cells in the layout.  "surround" unexpannds cells which
+ *	the cursor box surrounds completely, and "overlap" unexpands
+ *	cells which the cursor box overlaps.
+ *
+ *	For backwards compatibility:
+ *	"unexpand" alone implements "unexpand surround".
+ *
+ *	Also see:  CmdExpand
  *
  * Results:
  *	None.
  *
  * Side effects:
- *	Unexpands all cells under the box that don't completely
- *	contain the box.
+ *	Changes the expansion state of cells.
  *
  * ----------------------------------------------------------------------------
  */
 
+#define UNEXPAND_SELECTION	0
+#define UNEXPAND_SURROUND	1
+#define UNEXPAND_OVERLAP	2
+#define UNEXPAND_ALL		3
+#define UNEXPAND_HELP		4
+
 void
 CmdUnexpand(
     MagWindow *w,
     TxCommand *cmd)
 {
-    int windowMask, boxMask;
+    int windowMask, boxMask, option;
+    const char * const *msg;
     Rect rootRect;
+
     int cmdUnexpandFunc(CellUse *use, int windowMask);		/* Forward reference. */
 
-    if (cmd->tx_argc != 1)
+    static const char * const cmdUnexpandOption[] = {
+	"selection	expand cell instances in the selection",
+	"surround	expand cell instances which the cursor box surrounds",
+	"overlap	expand cell instances which the cursor box overlaps",
+	"all		expand all cell instances",
+	NULL
+    };
+
+    if (cmd->tx_argc > 1)
     {
-	TxError("Usage: %s\n", cmd->tx_argv[0]);
-	return;
+	option = Lookup(cmd->tx_argv[1], cmdUnexpandOption);
+	if (option < 0) option = UNEXPAND_HELP;
     }
+    else
+	option = UNEXPAND_SURROUND;
+
+    if (option == UNEXPAND_HELP) goto badusage; 
 
     windCheckOnlyWindow(&w, DBWclientID);
     if (w == (MagWindow *) NULL)
@@ -723,8 +773,42 @@ CmdUnexpand(
 	TxError("The box isn't in the same window as the cursor.\n");
 	return;
     }
-    DBExpandAll(((CellUse *) w->w_surfaceID), &rootRect, windowMask,
-	    FALSE, cmdUnexpandFunc, (ClientData)(pointertype) windowMask);
+
+    switch (option)
+    {
+	case UNEXPAND_SELECTION:
+	    SelectExpand(windowMask, DB_UNEXPAND, (Rect *)NULL);
+	    break;
+	case UNEXPAND_OVERLAP:
+	    DBExpandAll(((CellUse *)w->w_surfaceID), &rootRect, windowMask,
+			DB_UNEXPAND | DB_EXPAND_OVERLAP,
+			cmdUnexpandFunc, (ClientData)(pointertype)windowMask);
+	    SelectExpand(windowMask,
+			DB_UNEXPAND | DB_EXPAND_OVERLAP,
+			&rootRect);
+	    break;
+	case UNEXPAND_SURROUND:
+	    DBExpandAll(((CellUse *)w->w_surfaceID), &rootRect, windowMask,
+			DB_UNEXPAND | DB_EXPAND_SURROUND,
+			cmdUnexpandFunc, (ClientData)(pointertype)windowMask);
+	    SelectExpand(windowMask,
+			DB_UNEXPAND | DB_EXPAND_SURROUND,
+			&rootRect);
+	    break;
+	case UNEXPAND_ALL:
+	    DBExpandAll(((CellUse *)w->w_surfaceID), &TiPlaneRect, windowMask,
+			DB_UNEXPAND | DB_EXPAND_OVERLAP,
+			cmdUnexpandFunc, (ClientData)(pointertype)windowMask);
+	    SelectExpand(windowMask,
+			DB_UNEXPAND | DB_EXPAND_OVERLAP,
+			(Rect *)NULL);
+	    break;
+    }
+    return;
+
+badusage:
+    for (msg = &(cmdUnexpandOption[0]); *msg != NULL; msg++)
+        TxPrintf("    %s\n", *msg);
 }
 
 /* This function is called for each cell whose expansion status changed.
@@ -743,6 +827,182 @@ cmdUnexpandFunc(
     return 0;
 }
 
+/*
+ * ----------------------------------------------------------------------------
+ *
+ * CmdUnits --
+ *
+ * Implement the "units" command.
+ *
+ * Usage:
+ *	units [value] [print|noprint]
+ *
+ *	where "value" may be one of "default", "internal", "lambda",
+ *	"user" (equivalently "grid"), or "microns".
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	The global variable DBWUnits may be changed, which changes the
+ *	behavior of magic when interpreting un-suffixed values or
+ *	displaying values.
+ *
+ * Notes:
+ *	The units behavior was previously dependent on what command was
+ *	issued, with results usually being given in internal units, and
+ *	with un-suffixed values following the snap behavior.  Backwards-
+ *	compatible behavior is used on startup or at any time by setting
+ *	the units to "default".  Otherwise, unit display follows the
+ *	given "units" setting.
+ *	
+ * ----------------------------------------------------------------------------
+ */
+
+#define UNITS_DEFAULT	0
+#define UNITS_INTERNAL	1
+#define UNITS_LAMBDA	2
+#define UNITS_GRID	3
+#define UNITS_USER	4
+#define UNITS_MICRONS	5
+#define UNITS_LIST	6
+#define UNITS_PRINT	7
+#define UNITS_NOPRINT	8
+
+void
+CmdUnits(
+    MagWindow *w,
+    TxCommand *cmd)
+{
+    static const char * const names[] = { "default", "internal", "lambda",
+		"grid", "user", "microns", "list", "print", "noprint", 0 };
+    int idx, n = UNITS_LIST, n2, saveflag;
+    DBWclientRec *crec;
+
+    if (cmd->tx_argc >= 2)
+    {
+	n = Lookup(cmd->tx_argv[1], names);
+	if (n < 0)
+	{
+	    TxPrintf("Usage: units [default | internal | lambda | microns"
+			" | user] [print]\n");
+	    return;
+	}
+	if (DBWUnits != DBW_UNITS_DEFAULT)
+	    saveflag = DBWUnits & DBW_UNITS_PRINT_FLAG;
+	else
+	    saveflag = -1;
+
+	switch (n)
+	{
+	    case UNITS_DEFAULT:
+		DBWUnits = DBW_UNITS_DEFAULT;
+		break;
+	    case UNITS_INTERNAL:
+		DBWUnits = DBW_UNITS_INTERNAL;
+		break;
+	    case UNITS_LAMBDA:
+		DBWUnits = DBW_UNITS_LAMBDA;
+		break;
+	    case UNITS_USER:
+	    case UNITS_GRID:
+		DBWUnits = DBW_UNITS_USER;
+		break;
+	    case UNITS_MICRONS:
+		DBWUnits = DBW_UNITS_MICRONS;
+		break;
+	    case UNITS_PRINT:
+		saveflag = DBW_UNITS_PRINT_FLAG;
+		break;
+	    case UNITS_NOPRINT:
+		saveflag = 0;
+		break;
+	}
+	if (n < 0)
+	{
+	    TxError("Unrecognized units option %s\n.", cmd->tx_argv[1]);
+	    return;
+	}
+	if (n != UNITS_LIST)
+	{
+	    if ((cmd->tx_argc == 3) && (n != UNITS_DEFAULT))
+	    {
+		n2 = Lookup(cmd->tx_argv[2], names);
+		switch (n2)
+		{
+		    case UNITS_PRINT:
+			DBWUnits |= DBW_UNITS_PRINT_FLAG; 
+			break;
+		    case UNITS_NOPRINT:
+			DBWUnits &= DBW_UNITS_TYPE_MASK; 
+			break;
+		    default:
+			TxError("Unrecognized units option %s\n.", cmd->tx_argv[2]);
+			break;
+		}
+	    }
+	    else if ((n != UNITS_DEFAULT) && (saveflag != -1))
+	    {
+		/* Preserve the previous value of the print/noprint flag */
+		DBWUnits &= DBW_UNITS_TYPE_MASK;
+		DBWUnits |= saveflag;
+	    }
+	    return;
+	}
+    }
+
+    if (DBWUnits == DBW_UNITS_DEFAULT)
+	idx = UNITS_DEFAULT;
+    else
+	switch (DBWUnits & DBW_UNITS_TYPE_MASK)
+	{
+	    case DBW_UNITS_INTERNAL:
+		idx = UNITS_INTERNAL;
+		break;
+	    case DBW_UNITS_LAMBDA:
+		idx = UNITS_LAMBDA;
+		break;
+	    case DBW_UNITS_USER:
+		idx = UNITS_USER;
+		break;
+	    case DBW_UNITS_MICRONS:
+		idx = UNITS_MICRONS;
+		break;
+	}
+
+    if (n == UNITS_LIST)		/* list */
+    {
+#ifdef MAGIC_WRAPPER
+	Tcl_Obj *tobj;
+	tobj = Tcl_NewListObj(0, NULL);
+	Tcl_ListObjAppendElement(magicinterp, tobj,
+		Tcl_NewStringObj((char *)names[idx], -1));
+	if (idx != UNITS_DEFAULT)
+	{
+	    if (DBWUnits & DBW_UNITS_PRINT_FLAG)
+		Tcl_ListObjAppendElement(magicinterp, tobj,
+			Tcl_NewStringObj("print", 5));
+	    else
+		Tcl_ListObjAppendElement(magicinterp, tobj,
+			Tcl_NewStringObj("noprint", 7));
+	}
+	Tcl_SetObjResult(magicinterp, tobj);
+#else
+	TxPrintf("%s", names[idx]);
+	if (idx != UNITS_DEFAULT)
+	    if (DBWUnits & DBW_UNITS_PRINT_FLAG)
+		TxPrintf(" print");
+	TxPrintf("\n");
+#endif
+    }
+    else if (idx == UNITS_DEFAULT)
+	TxPrintf("Reported units follow the snap setting.\n");
+    else if (DBWUnits & DBW_UNITS_PRINT_FLAG)
+	TxPrintf("Values are reported as %s, along with the units.\n", names[idx]);
+    else
+	TxPrintf("Values are reported as %s\n", names[idx]);
+}
+
 /*
  * ----------------------------------------------------------------------------
  *
@@ -830,7 +1090,8 @@ struct linked_id {
 
 int
 cmdWhatPrintCell(
-   Tile *tile,
+   Tile *tile,		/* (unused) */
+   TileType dinfo,	/* (unused) */
    TreeContext *cxp)
 {
     struct linked_id **lid = (struct linked_id **)cxp->tc_filter->tf_arg;
@@ -885,6 +1146,7 @@ static LabelStore *labelBlockTop, *labelEntry;
 int
 cmdFindWhatTileFunc(
     Tile *tile,
+    TileType dinfo,
     ClientData clientData)
 {
     struct linked_id **lid = (struct linked_id **)clientData;
@@ -896,7 +1158,7 @@ cmdFindWhatTileFunc(
     scx.scx_use = EditCellUse;
     scx.scx_trans = GeoIdentityTransform;
 
-    if (SplitSide(tile))
+    if (dinfo & TT_SIDE)
 	type = SplitRightType(tile);
     else
 	type = SplitLeftType(tile);
@@ -1094,11 +1356,13 @@ CmdWhat(
 			}
 #endif
 
-		        while (lid != NULL)
-		        {
-			   freeMagic(lid);
+			free_magic1_t mm1 = freeMagic1_init();
+			while (lid != NULL)
+			{
+			   freeMagic1(&mm1, lid);
 			   lid = lid->lid_next;
 			}
+			freeMagic1_end(&mm1);
 #ifdef MAGIC_WRAPPER
 			if (doListAll)
 			    Tcl_ListObjAppendElement(magicinterp, paintobj,
@@ -1681,18 +1945,20 @@ CmdWire(
 	case VALUES:
 	    if (locargc == 2)
 	    {
+		char *wdisp;
 		width = WireGetWidth();
 		type = WireGetType();
+		wdisp = DBWPrintValue(width, w, TRUE);
 #ifdef MAGIC_WRAPPER
 		lobj = Tcl_NewListObj(0, NULL);
-		Tcl_ListObjAppendElement(magicinterp, lobj,
-				Tcl_NewIntObj(width));
 		Tcl_ListObjAppendElement(magicinterp, lobj,
 				Tcl_NewStringObj(DBTypeLongNameTbl[type], -1));
+		Tcl_ListObjAppendElement(magicinterp, lobj,
+				Tcl_NewStringObj(wdisp, -1));
 		Tcl_SetObjResult(magicinterp, lobj);
 #else
-		TxPrintf("Wire layer %s, width %d\n",
-			DBTypeLongNameTbl[type], width);
+		TxPrintf("Wire layer %s, width %s\n",
+			DBTypeLongNameTbl[type], wdisp);
 #endif
 	    }
 	    break;
@@ -1717,12 +1983,14 @@ CmdWire(
 	case WIDTH:
 	    if (locargc == 2)
 	    {
+		char *wdisp;
 		width = WireGetWidth();
+		wdisp = DBWPrintValue(width, w, TRUE);
 #ifdef MAGIC_WRAPPER
-		lobj = Tcl_NewIntObj(width);
+		lobj = Tcl_NewStringObj(wdisp, -1);
 		Tcl_SetObjResult(magicinterp, lobj);
 #else
-		TxPrintf("Wire width is %d\n", width);
+		TxPrintf("Wire width is %s\n", wdisp);
 #endif
 	    }
 	    else if (locargc != 3)
@@ -1945,7 +2213,7 @@ CmdWriteall(
 	option = Lookup(cmd->tx_argv[1], writeallOpts);
 	if (option < 0)
 	{
-	    TxError("Usage: %s [force|modified|noupdate [cellname ...]]\n",
+	    TxError("Usage: %s [force|modified [cellname ...]]\n",
 		    cmd->tx_argv[0]);
 	    return;
 	}

commands/CmdWizard.c

@@ -47,6 +47,10 @@ static const char rcsid[] __attribute__ ((unused)) = "$Header: /usr/cvsroot/magi
 #include "utils/utils.h"
 #include "textio/txcommands.h"
 
+/* For diagnostics */
+#include "cif/CIFint.h"
+#include "database/databaseInt.h"
+
 /* C99 compat */
 #include "extract/extract.h"
 
@@ -189,6 +193,234 @@ CmdExtractTest(
 }
 #endif
 
+/*
+ * ----------------------------------------------------------------------------
+ *
+ * tileCountProc --
+ *
+ *	Routine to count tiles.
+ *
+ * Return:
+ *	0 to keep the search going
+ *
+ * Side effects:
+ *	Keeps count in clientData
+ *
+ * ----------------------------------------------------------------------------
+ */
+
+int
+tileCountProc(
+    Tile *tile,		/* (unused) */
+    TileType dinfo,	/* (unused) */
+    int *tcount)
+{
+    (*tcount)++;
+    return 0;
+}
+
+/*
+ * ----------------------------------------------------------------------------
+ *
+ * showMem --
+ * CmdShowmem --
+ *
+ * Usage:
+ *
+ *	showmem [outfile]
+ *
+ * Display all the (principle) internal memory usage for tiles, including
+ * all cell defs, and all CIF generated planes.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	May write to a disk file.
+ *
+ * ----------------------------------------------------------------------------
+ */
+
+void
+showMem(
+    FILE *outf,		/* File to which information is to be output */
+    bool verbose)	/* If TRUE, output detailed erase table */
+{
+    int ttotal, ttotal1, ttotal2;
+    int i;
+    Plane *plane;
+    CellDef *def;
+    int pNum;
+    HashSearch hs;
+    HashEntry *entry;
+
+    fprintf(outf, "Tile memory usage summary\n");
+    fprintf(outf, "Technology %s\n", DBTechName);
+
+    /* Search every cell def (including internal ones), count tiles,
+     * and add up the tile memory usage on every plane.
+     */
+
+    /* Search the CIFPlanes and count tiles. */
+    /* CIFPlanes, CIFTotalPlanes, CIFComponentPlanes */
+
+    ttotal2 = 0;
+    if (CIFCurStyle != NULL)
+    {
+	fprintf(outf, "\nCIFPlanes:\n");
+	ttotal1 = 0;
+	for (i = 0; i < MAXCIFLAYERS; i++)
+	{
+	    plane = CIFPlanes[i];
+	    if (plane != NULL)
+	    {
+		ttotal = 0;
+		DBSrPaintArea((Tile *)NULL, plane, &TiPlaneRect,
+			&DBAllTypeBits, tileCountProc, &ttotal);
+		ttotal1 += ttotal;
+
+		if (CIFCurStyle->cs_layers[i])
+		    fprintf(outf, "   layer %s: %ld\n",
+				CIFCurStyle->cs_layers[i]->cl_name,
+				(long)ttotal * (long)sizeof(Tile));
+		else
+		    fprintf(outf, "   layer %d: %d\n", i,
+				(long)ttotal * (long)sizeof(Tile));
+	    }
+	}
+	fprintf(outf, "   Subtotal: %ld bytes\n",
+			(long)ttotal1 * (long)sizeof(Tile));
+	ttotal2 += ttotal1;
+
+	fprintf(outf, "\nCIFTotalPlanes\n");
+	ttotal1 = 0;
+	for (i = 0; i < MAXCIFLAYERS; i++)
+	{
+	    plane = CIFTotalPlanes[i];
+	    if (plane != NULL)
+	    {
+		ttotal = 0;
+		DBSrPaintArea((Tile *)NULL, plane, &TiPlaneRect,
+			&DBAllTypeBits, tileCountProc, &ttotal);
+		ttotal1 += ttotal;
+
+		if (CIFCurStyle->cs_layers[i])
+		    fprintf(outf, "   layer %s: %ld\n",
+				CIFCurStyle->cs_layers[i]->cl_name,
+				(long)ttotal * (long)sizeof(Tile));
+		else
+		    fprintf(outf, "   layer %d: %d\n", i,
+				(long)ttotal * (long)sizeof(Tile));
+	    }
+	}
+	fprintf(outf, "   Subtotal: %ld bytes\n",
+			(long)ttotal1 * (long)sizeof(Tile));
+	ttotal2 += ttotal1;
+
+	fprintf(outf, "\nCIFComponentPlanes\n");
+	ttotal1 = 0;
+	for (i = 0; i < MAXCIFLAYERS; i++)
+	{
+	    plane = CIFComponentPlanes[i];
+	    if (plane != NULL)
+	    {
+		ttotal = 0;
+		DBSrPaintArea((Tile *)NULL, plane, &TiPlaneRect,
+			&DBAllTypeBits, tileCountProc, &ttotal);
+		ttotal1 += ttotal;
+
+		if (CIFCurStyle->cs_layers[i])
+		    fprintf(outf, "   layer %s: %ld bytes\n",
+				CIFCurStyle->cs_layers[i]->cl_name,
+				(long)ttotal * (long)sizeof(Tile));
+		else
+		    fprintf(outf, "   layer %d: %ld bytes\n", i,
+				(long)ttotal * (long)sizeof(Tile));
+	    }
+	}
+	fprintf(outf, "   Subtotal: %ld bytes\n",
+			(long)ttotal1 * (long)sizeof(Tile));
+	ttotal2 += ttotal1;
+    }
+    else
+    {
+	fprintf(outf, "CIF planes:  No memory usage\n");
+    }
+
+    HashStartSearch(&hs);
+    while ((entry = HashNext(&dbCellDefTable, &hs)) != NULL)
+    {
+	def = (CellDef *)HashGetValue(entry);
+	if (def != (CellDef *)NULL)
+	{
+	    fprintf(outf, "\nCell def %s\n", def->cd_name);
+	    ttotal1 = 0;
+	    for (pNum = 0; pNum < DBNumPlanes; pNum++)
+	    {
+		plane = def->cd_planes[pNum];
+		if (plane != NULL)
+		{
+		    ttotal = 0;
+		    DBSrPaintArea((Tile *)NULL, plane, &TiPlaneRect,
+				&DBAllTypeBits, tileCountProc, &ttotal);
+
+		    fprintf(outf, "   plane %s: %ld bytes\n",
+				DBPlaneLongNameTbl[pNum],
+				(long)ttotal * (long)sizeof(Tile));
+		    ttotal1 += ttotal;
+		}
+	    }
+	    fprintf(outf, "   Subtotal: %ld bytes\n",
+			(long)ttotal1 * (long)sizeof(Tile));
+	    ttotal2 += ttotal1;
+	}
+    }
+    fprintf(outf, "   Grand total: %ld bytes\n",
+			(long)ttotal2 * (long)sizeof(Tile));
+}
+
+void
+CmdShowmem(
+    MagWindow *w,
+    TxCommand *cmd)
+{
+    FILE *outf;
+    bool verbose;
+    char **av;
+    int ac;
+
+    if (cmd->tx_argc > 3)
+    {
+	TxError("Usage: showmem [-v] [file]\n");
+	return;
+    }
+
+    verbose = FALSE;
+    av = &cmd->tx_argv[1];
+    ac = cmd->tx_argc - 1;
+
+    outf = stdout;
+    if (ac > 0 && strcmp(av[0], "-v") == 0)
+    {
+	verbose = TRUE;
+	av++, ac--;
+    }
+
+    if (ac > 0)
+    {
+	outf = fopen(av[0], "w");
+	if (outf == (FILE *) NULL)
+	{
+	    perror(av[0]);
+	    TxError("Nothing written\n");
+	    return;
+	}
+    }
+
+    showMem(outf, verbose);
+    if (outf != stdout)
+	(void) fclose(outf);
+}
 
 /*
  * ----------------------------------------------------------------------------
@@ -232,7 +464,7 @@ showTech(
     fprintf(outf, "\n");
     fprintf(outf, "Types:\n");
     for (i = 0; i < DBNumTypes; i++) {
-	int pl ; char *spl ;
+	int pl ; const char *spl ;
 
 	pl = DBPlane(i);
 	spl = ( pl <= 0 || pl > DBNumPlanes ) ? "??" : DBPlaneLongName(pl);
@@ -569,11 +801,13 @@ cmdStatsCount(
     CellDef *def,
     struct countClient *cc)
 {
-    int cmdStatsCountTile(Tile *tile, struct cellInfo *ci);
     int pNum;
     struct cellInfo *ci;
     TileType t;
 
+    /* Forward declaration */
+    int cmdStatsCountTile(Tile *tile, TileType dinfo, struct cellInfo *ci);
+
     if (def->cd_client)
 	return (1);
 
@@ -598,6 +832,7 @@ cmdStatsCount(
 int
 cmdStatsCountTile(
     Tile *tile,
+    TileType dinfo,		/* (unused) */
     struct cellInfo *ci)
 {
     TileType type = TiGetType(tile);
@@ -868,17 +1103,18 @@ CmdTsearch(
     MagWindow *w,
     TxCommand *cmd)
 {
-    int cmdTsrFunc(Tile *tp);
-    char *RunStats(int flags, struct tms *lastt, struct tms *deltat);
     char *rstatp;
     static TileTypeBitMask mask;
     static struct tms tlast, tdelta;
     Rect rtool, rsearch;
-    /**** Rect *ebox; ****/
     Plane *plane;
     int i, pNum, count;
     int usPerSearch, usPerTile, usPerL2, us, boxarea;
 
+    /* Forward declarations */
+    int cmdTsrFunc(Tile *tp, TileType dinfo, ClientData clientdata);
+    char *RunStats(int flags, struct tms *lastt, struct tms *deltat);
+
     if (cmd->tx_argc < 3 || cmd->tx_argc > 5)
     {
 	TxError("Usage: tsearch plane count [mask [new|mayo]]\n");
@@ -978,10 +1214,12 @@ CmdTsearch(
 
 int
 cmdTsrFunc(
-    Tile *tp)
+    Tile *tp,
+    TileType dinfo,		/* (unused) */
+    ClientData clientdata)	/* (unused) */
 {
     if (cmdTsearchDebug)
-	TxPrintf("%lx\n", (intmax_t) tp);
+	TxPrintf("%lx\n", (intptr_t) tp);
     numTilesFound++;
     return 0;
 }
@@ -1047,7 +1285,7 @@ CmdWatch(
 	pNum = DBTechNamePlane(cmd->tx_argv[1]);
 	if (pNum < 0)
 	{
-	    char *cp;
+	    const char *cp;
 	    TxError("Unrecognized plane: %s.  Legal names are:\n",
 		    cmd->tx_argv[1]);
 	    for(pNum=0; pNum < PL_MAXTYPES; pNum++) {

commands/Makefile

@@ -12,10 +12,9 @@ SRCS      = CmdSubrs.c CmdAB.c CmdCD.c CmdE.c CmdFI.c \
 
 module: ${MAGICDIR}/readline/readline lib${MODULE}.o
 
+# Delegate this task to the readline/Makefile
 ${MAGICDIR}/readline/readline:
-	@if ( ! test -f ${MAGICDIR}/readline/readline ) ; then \
-	(cd ${MAGICDIR}/readline; ln -s `ls | grep readline` readline) ; \
-	fi
+	${MAKE} -C ${MAGICDIR}/readline readline-create-symlinks
 
 include ${MAGICDIR}/defs.mak
 include ${MAGICDIR}/rules.mak

commands/commands.h

@@ -20,8 +20,8 @@
  * rcsid $Header: /usr/cvsroot/magic-8.0/commands/commands.h,v 1.3 2009/01/19 15:43:03 tim Exp $
  */
 
-#ifndef _COMMANDS_H
-#define	_COMMANDS_H
+#ifndef _MAGIC__COMMANDS__COMMANDS_H
+#define	_MAGIC__COMMANDS__COMMANDS_H
 
 #include "windows/windows.h"
 #include "database/database.h"
@@ -72,7 +72,7 @@ extern int cmdParseCoord(MagWindow *w, char *arg, bool is_relative, bool is_x);
 extern void cmdSaveCell(CellDef *cellDef, char *newName, bool noninteractive, bool tryRename);
 extern void CmdInit(void);
 
-extern void CmdDoProperty(CellDef *def, TxCommand *cmd, int argstart);
+extern void CmdDoProperty(CellDef *def, MagWindow *w, TxCommand *cmd, int argstart);
 extern void CmdPaintEraseButton(MagWindow *w, Point *refPoint, bool isPaint, bool isScreen);
 
-#endif /* _COMMANDS_H */
+#endif /* _MAGIC__COMMANDS__COMMANDS_H */

configure

@@ -9,4 +9,4 @@
 # script itself.  It also sets up CFLAGS without the default optimizer
 # flag (-O2).
 
-( CFLAGS="-g"; export CFLAGS; cd scripts ; ./configure "$@" )
+( CFLAGS=${CFLAGS:-"-g"}; export CFLAGS; cd scripts ; ./configure "$@" )

database/DBbound.c

@@ -30,19 +30,32 @@ static char rcsid[] __attribute__ ((unused)) = "$Header: /usr/cvsroot/magic-8.0/
 typedef struct dbcellboundstruct
 {
     Rect *area;
-    bool extended;
+    Rect *extended;
     bool found;
 } DBCellBoundStruct;
 
 /*
  * --------------------------------------------------------------------
+ * DBBoundCellPlane ---
+ *
+ *	Find the extents of all subcells of the cell "def", both the
+ *	extent of geometry (rect) and the extent of geometry plus any
+ *	labels extending outside the extent of geometry (extended).
+ *
+ * Results:
+ *	TRUE if subcells were found and measured;  FALSE if no subcells
+ *	were found (in which case "extended" and "rect" may not be
+ *	valid).
+ *
+ * Side effects:
+ *	Values may be recorded in "extended" and "rect".
  * --------------------------------------------------------------------
  */
 
 int
 DBBoundCellPlane(def, extended, rect)
     CellDef *def;
-    bool extended;
+    Rect *extended;
     Rect *rect;
 {
     TreeFilter filter;
@@ -70,25 +83,19 @@ dbCellBoundFunc(use, fp)
     CellUse *use;
     TreeFilter *fp;
 {
-    Rect *bbox;
     DBCellBoundStruct *cbs;
 
     cbs = (DBCellBoundStruct *)fp->tf_arg;
 
-    bbox = &use->cu_bbox;
     if (cbs->found)
     {
-	if (cbs->extended)
-	    GeoInclude(&use->cu_extended, cbs->area);
-	else
-	    GeoInclude(&use->cu_bbox, cbs->area);
+	GeoInclude(&use->cu_extended, cbs->extended);
+	GeoInclude(&use->cu_bbox, cbs->area);
     }
     else
     {
-	if (cbs->extended)
-	    *cbs->area = use->cu_extended;
-	else
-	    *cbs->area = use->cu_bbox;
+	*cbs->extended = use->cu_extended;
+	*cbs->area = use->cu_bbox;
 	cbs->found = TRUE;
     }
     return 0;

database/DBcell.c

@@ -108,16 +108,55 @@ DBCellFindDup(use, parent)
 		"DBCellFindDup");
     while ((dupUse = BPEnumNext(&bpe)))
 	if (dupUse->cu_def == use->cu_def)
+	{
+	    bool transMatch, arrayMatch, notXarray, notYarray;
+
 	    /* Transforms must be equal---Aligned bounding boxes are
-	     * an insufficient measure of exact overlap.
+	     * an insufficient measure of exact overlap.  Also, array
+	     * counts and separation must match for arrayed devices
 	     */
-	    if ((dupUse->cu_transform.t_a == use->cu_transform.t_a) &&
+	    transMatch = ((dupUse->cu_transform.t_a == use->cu_transform.t_a) &&
 			(dupUse->cu_transform.t_b == use->cu_transform.t_b) &&
 			(dupUse->cu_transform.t_c == use->cu_transform.t_c) &&
 			(dupUse->cu_transform.t_d == use->cu_transform.t_d) &&
 			(dupUse->cu_transform.t_e == use->cu_transform.t_e) &&
-			(dupUse->cu_transform.t_f == use->cu_transform.t_f))
+			(dupUse->cu_transform.t_f == use->cu_transform.t_f));
+
+	    /* First check if both use and dupUse are not arrays. */
+	    notXarray = (dupUse->cu_xhi == dupUse->cu_xlo) &&
+			(use->cu_xhi == use->cu_xlo);
+
+	    notYarray =	(dupUse->cu_yhi == dupUse->cu_ylo) &&
+			(use->cu_yhi == use->cu_ylo);
+
+	    arrayMatch = (notXarray && notYarray);
+
+	    /* If they are arrays, then the array parameters must match. */
+
+	    if (!notXarray && notYarray)
+	    {
+		arrayMatch = ((dupUse->cu_xhi - dupUse->cu_xlo) ==
+				(use->cu_xhi - use->cu_xlo)) &&
+				(dupUse->cu_xsep == use->cu_xsep);
+	    }
+	    else if (!notYarray && notXarray)
+	    {
+		arrayMatch = ((dupUse->cu_yhi - dupUse->cu_ylo) ==
+				(use->cu_yhi - use->cu_ylo)) &&
+				(dupUse->cu_ysep == use->cu_ysep);
+	    }
+	    else if (!notYarray && !notXarray)
+	    {
+		arrayMatch = (((dupUse->cu_xhi - dupUse->cu_xlo) ==
+				(use->cu_xhi - use->cu_xlo)) &&
+				(dupUse->cu_xsep == use->cu_xsep)) &&
+				(((dupUse->cu_yhi - dupUse->cu_ylo) ==
+				(use->cu_yhi - use->cu_ylo)) &&
+				(dupUse->cu_ysep == use->cu_ysep));
+	    }
+	    if (transMatch && arrayMatch)
 		break;
+	}
 
     BPEnumTerm(&bpe);
     return dupUse;

database/DBcellbox.c

@@ -59,15 +59,15 @@ static char rcsid[] __attribute__ ((unused)) = "$Header: /usr/cvsroot/magic-8.0/
  */
 
 char *
-DBPrintUseId(scx, name, size, display_only)
-    SearchContext *scx;	/* Pointer to current search context, specifying a
+DBPrintUseId(
+    SearchContext *scx,	/* Pointer to current search context, specifying a
 			 * cell use and X,Y array indices.
 			 */
-    char *name;		/* Pointer to string into which we will copy the
+    char *name,		/* Pointer to string into which we will copy the
 			 * print name of this instance.
 			 */
-    int size;		/* Maximum number of characters to copy into string. */
-    bool display_only;	/* TRUE if called for displaying only */
+    int size,		/* Maximum number of characters to copy into string. */
+    bool display_only)	/* TRUE if called for displaying only */
 {
     CellUse *use = scx->scx_use;
     char *sp, *id, *ep;
@@ -619,8 +619,9 @@ dbReComputeBboxFunc(cellDef, boundProc, recurseProc)
     /*
      * Include area of subcells separately
      */
-    if ((foundAny = DBBoundCellPlane(cellDef, TRUE, &rect)) > 0)
-	area = rect;
+    if (!((foundAny = DBBoundCellPlane(cellDef, &extended, &rect)) > 0))
+	extended = GeoNullRect;
+    area = rect;
 
     for (pNum = PL_PAINTBASE; pNum < DBNumPlanes; pNum++)
 	if (pNum != PL_DRC_CHECK)
@@ -634,7 +635,7 @@ dbReComputeBboxFunc(cellDef, boundProc, recurseProc)
 	    }
 
     /*
-     * Include the area of labels, too.
+     * Include the area of label anchors, too.
      */
     for (label = cellDef->cd_labels; label != NULL;  label = label->lab_next)
     {
@@ -656,7 +657,11 @@ dbReComputeBboxFunc(cellDef, boundProc, recurseProc)
 	}
     }
 
-    extended = area;
+    /* Make sure the extended bounding box includes the area of all
+     * paint material just found, then include the area of all text
+     * in the current cell.
+     */
+    GeoInclude(&area, &extended);
     if (foundAny)
     {
 	for (label = cellDef->cd_labels; label != NULL;  label = label->lab_next)
@@ -673,6 +678,7 @@ dbReComputeBboxFunc(cellDef, boundProc, recurseProc)
 	degenerate = TRUE;
 	area.r_xbot = area.r_ybot = 0;
 	area.r_xtop = area.r_ytop = 1;
+	extended = area;
     }
     else degenerate = FALSE;
 
@@ -687,7 +693,11 @@ dbReComputeBboxFunc(cellDef, boundProc, recurseProc)
     if (area.r_ybot == area.r_ytop)
 	area.r_ytop = area.r_ybot + 1;
 
-    if (degenerate) extended = area;
+    if (extended.r_xbot == extended.r_xtop)
+	extended.r_xtop = extended.r_xbot + 1;
+
+    if (extended.r_ybot == extended.r_ytop)
+	extended.r_ytop = extended.r_ybot + 1;
 
     /* Did the bounding box change?  If not then there's no need to
      * recompute the parents.  If the cell has no material, then

database/DBcellcopy.c

@@ -37,9 +37,8 @@ static char rcsid[] __attribute__ ((unused)) = "$Header: /usr/cvsroot/magic-8.0/
 #include "windows/windows.h"
 #include "dbwind/dbwind.h"
 #include "commands/commands.h"
-
-/* C99 compat */
 #include "graphics/graphics.h"
+#include "cif/CIFint.h"
 
 /*
  * The following variable points to the tables currently used for
@@ -357,9 +356,43 @@ DBCellCheckCopyAllPaint(scx, mask, xMask, targetUse, func)
 struct propUseDefStruct {
    CellDef *puds_source;
    CellDef *puds_dest;
+   Plane *puds_plane;		/* Mask hint plane in dest */
    Transform *puds_trans;	/* Transform from source use to dest */
+   Rect *puds_area;		/* Clip area in source coordinates */
 };
 
+/*
+ *-----------------------------------------------------------------------------
+ *
+ * dbCopyMaskHintPlaneFunc --
+ *
+ *	Translate tiles from a child mask-hint property plane into the
+ *	coordinate system of the parent, and paint the mask-hint area
+ *	into the mask-hint property plane of the parent.
+ *
+ *-----------------------------------------------------------------------------
+ */
+
+int
+dbCopyMaskHintPlaneFunc(Tile *tile,
+    TileType dinfo,
+    struct propUseDefStruct *puds)
+{
+    Transform *trans = puds->puds_trans;
+    Rect *clip = puds->puds_area;
+    Rect r, rnew;
+    Plane *plane = puds->puds_plane;
+    
+    TiToRect(tile, &r);
+    GeoClip(&r, clip);
+    if (!GEO_RECTNULL(&r))
+    {
+	GeoTransRect(trans, &r, &rnew);
+	DBPaintPlane(plane, &rnew, CIFPaintTable, (PaintUndoInfo *)NULL);
+    }
+    return 0;
+}
+
 /*
  *-----------------------------------------------------------------------------
  *
@@ -380,63 +413,52 @@ struct propUseDefStruct {
  */
 
 int
-dbCopyMaskHintsFunc(key, value, puds)
+dbCopyMaskHintsFunc(key, proprec, puds)
     char *key;
-    ClientData value;
+    PropertyRecord *proprec;
     struct propUseDefStruct *puds;
 {
     CellDef *dest = puds->puds_dest;
     Transform *trans = puds->puds_trans;
-    char *propstr = (char *)value;
+    Rect *clip = puds->puds_area;
+    PropertyRecord *parentproprec, *newproprec;
     char *parentprop, *newvalue, *vptr;
     Rect r, rnew;
     bool propfound;
+    int i, j;
 
     if (!strncmp(key, "MASKHINTS_", 10))
     {
 	char *vptr, *lastval;
 	int lastlen;
+	Plane *plane;
 
-	/* Append to existing mask hint (if any) */
-	parentprop = (char *)DBPropGet(dest, key, &propfound);
-	newvalue = (propfound) ? StrDup((char **)NULL, parentprop) : (char *)NULL;
+	ASSERT(proprec->prop_type == PROPERTY_TYPE_PLANE, "dbCopyMaskHintsFunc");
 
-	vptr = propstr;
-	while (*vptr != '\0')
+	/* Get the existing mask hint plane in the parent cell, and
+	 * create it if it does not already exist.
+	 */
+	parentproprec = (PropertyRecord *)DBPropGet(dest, key, &propfound);
+
+	if (propfound)
+	    plane = parentproprec->prop_value.prop_plane;
+	else
 	{
-	    if (sscanf(vptr, "%d %d %d %d", &r.r_xbot, &r.r_ybot,
-			&r.r_xtop, &r.r_ytop) == 4)
-	    {
-		GeoTransRect(trans, &r, &rnew);
-
-		lastval = newvalue;
-		lastlen = (lastval) ? strlen(lastval) : 0;
-		newvalue = mallocMagic(40 + lastlen);
-
-		if (lastval)
-		    strcpy(newvalue, lastval);
-		else
-		    *newvalue = '\0';
-
-		sprintf(newvalue + lastlen, "%s%d %d %d %d", (lastval) ?  " " : "",
-			rnew.r_xbot, rnew.r_ybot, rnew.r_xtop, rnew.r_ytop);
-		if (lastval) freeMagic(lastval);
-
-		while (*vptr && !isspace(*vptr)) vptr++;
-		while (*vptr && isspace(*vptr)) vptr++;
-		while (*vptr && !isspace(*vptr)) vptr++;
-		while (*vptr && isspace(*vptr)) vptr++;
-		while (*vptr && !isspace(*vptr)) vptr++;
-		while (*vptr && isspace(*vptr)) vptr++;
-		while (*vptr && !isspace(*vptr)) vptr++;
-		while (*vptr && isspace(*vptr)) vptr++;
-	    }
-	    else break;
+	    newproprec = (PropertyRecord *)mallocMagic(sizeof(PropertyRecord));
+	    newproprec->prop_type = PROPERTY_TYPE_PLANE;
+	    newproprec->prop_len = 0;
+	    plane = DBNewPlane((ClientData)TT_SPACE);
+	    newproprec->prop_value.prop_plane = plane;
+	    DBPropPut(dest, key, newproprec);
 	}
-	if (newvalue)
-	    DBPropPut(dest, key, newvalue);
-    }
+	puds->puds_plane = plane;
 
+	/* Copy the properties from child to parent */
+	DBSrPaintArea(PlaneGetHint(proprec->prop_value.prop_plane),
+		proprec->prop_value.prop_plane,
+		clip, &CIFSolidBits, dbCopyMaskHintPlaneFunc, 
+		(ClientData)puds);
+    }
     return 0;
 }
 
@@ -468,6 +490,7 @@ DBCellCopyMaskHints(child, parent, transform)
     puds.puds_source = child->cu_def;
     puds.puds_dest = parent;
     puds.puds_trans = transform;
+    puds.puds_area = (Rect *)&TiPlaneRect;
     DBPropEnum(child->cu_def, dbCopyMaskHintsFunc, (ClientData)&puds);
 }
 
@@ -501,6 +524,7 @@ dbFlatCopyMaskHintsFunc(scx, def)
     puds.puds_source = scx->scx_use->cu_def;
     puds.puds_dest = def;
     puds.puds_trans = &scx->scx_trans;
+    puds.puds_area = &scx->scx_area;
 
     DBPropEnum(use->cu_def, dbCopyMaskHintsFunc, (ClientData)&puds);
 
@@ -967,14 +991,15 @@ DBCellGenerateSimpleSubstrate(scx, subType, notSubMask, targetDef)
  */
 
 int
-dbEraseSubFunc(tile, cxp)
+dbEraseSubFunc(tile, dinfo, cxp)
     Tile *tile;			/* Pointer to source tile with shield type */
+    TileType dinfo;		/* Split tile information */
     TreeContext *cxp;		/* Context from DBTreeSrTiles */
 {
     SearchContext *scx;
     Rect sourceRect, targetRect;
     int pNum;
-    TileType type, loctype, subType;
+    TileType newdinfo, loctype, subType;
     Plane *plane;
     struct dbCopySubData *csd;	/* Client data */
 
@@ -983,12 +1008,14 @@ dbEraseSubFunc(tile, cxp)
     plane = csd->csd_plane;
     pNum = csd->csd_pNum;
     subType = csd->csd_subtype;
-    type = TiGetTypeExact(tile);
     if (IsSplit(tile))
     {
-	loctype = (SplitSide(tile)) ? SplitRightType(tile) : SplitLeftType(tile);
+	loctype = (dinfo & TT_SIDE) ? SplitRightType(tile) : SplitLeftType(tile);
 	if (loctype == TT_SPACE) return 0;
+	newdinfo = DBTransformDiagonal(TiGetTypeExact(tile) | dinfo, &scx->scx_trans);
     }
+    else
+	newdinfo = (TileType)0;
 
     /* Construct the rect for the tile */
     TITORECT(tile, &sourceRect);
@@ -998,7 +1025,7 @@ dbEraseSubFunc(tile, cxp)
 
     csd->csd_modified = TRUE;
 
-    return DBNMPaintPlane(plane, type, &targetRect, DBStdEraseTbl(subType, pNum),
+    return DBNMPaintPlane(plane, newdinfo, &targetRect, DBStdEraseTbl(subType, pNum),
 		(PaintUndoInfo *)NULL);
 }
 
@@ -1010,14 +1037,15 @@ dbEraseSubFunc(tile, cxp)
  */
 
 int
-dbPaintSubFunc(tile, cxp)
+dbPaintSubFunc(tile, dinfo, cxp)
     Tile *tile;			/* Pointer to source tile with shield type */
+    TileType dinfo;		/* Split tile information */
     TreeContext *cxp;		/* Context from DBTreeSrTiles */
 {
     SearchContext *scx;
     Rect sourceRect, targetRect;
     int pNum;
-    TileType type, loctype, subType;
+    TileType newdinfo, loctype, subType;
     Plane *plane;
     struct dbCopySubData *csd;	/* Client data */
 
@@ -1026,12 +1054,14 @@ dbPaintSubFunc(tile, cxp)
     plane = csd->csd_plane;
     pNum = csd->csd_pNum;
     subType = csd->csd_subtype;
-    type = TiGetTypeExact(tile);
     if (IsSplit(tile))
     {
-	loctype = (SplitSide(tile)) ? SplitRightType(tile) : SplitLeftType(tile);
+	loctype = (dinfo & TT_SIDE) ? SplitRightType(tile) : SplitLeftType(tile);
 	if (loctype == TT_SPACE) return 0;
+	newdinfo = DBTransformDiagonal(TiGetTypeExact(tile) | dinfo, &scx->scx_trans);
     }
+    else
+	newdinfo = (TileType)0;
 
     /* Construct the rect for the tile */
     TITORECT(tile, &sourceRect);
@@ -1041,7 +1071,7 @@ dbPaintSubFunc(tile, cxp)
 
     csd->csd_modified = TRUE;
 
-    return DBNMPaintPlane(plane, type, &targetRect, DBStdPaintTbl(subType, pNum),
+    return DBNMPaintPlane(plane, newdinfo, &targetRect, DBStdPaintTbl(subType, pNum),
 		(PaintUndoInfo *)NULL);
 }
 
@@ -1054,14 +1084,15 @@ dbPaintSubFunc(tile, cxp)
  */
 
 int
-dbEraseNonSub(tile, cxp)
+dbEraseNonSub(tile, dinfo, cxp)
     Tile *tile;			/* Pointer to tile to erase from target */
+    TileType dinfo;		/* Split tile information */
     TreeContext *cxp;		/* Context from DBTreeSrTiles */
 {
     SearchContext *scx;
     Rect sourceRect, targetRect;
     Plane *plane;		/* Plane of target data */
-    TileType type, loctype, subType;
+    TileType newdinfo, loctype, subType;
     struct dbCopySubData *csd;
     int pNum;
 
@@ -1072,12 +1103,14 @@ dbEraseNonSub(tile, cxp)
 
     scx = cxp->tc_scx;
 
-    type = TiGetTypeExact(tile);
     if (IsSplit(tile))
     {
-	loctype = (SplitSide(tile)) ? SplitRightType(tile) : SplitLeftType(tile);
+	loctype = (dinfo & TT_SIDE) ? SplitRightType(tile) : SplitLeftType(tile);
 	if (loctype == TT_SPACE) return 0;
+	newdinfo = DBTransformDiagonal(TiGetTypeExact(tile) | dinfo, &scx->scx_trans);
     }
+    else
+	newdinfo = (TileType)0;
 
     /* Construct the rect for the tile */
     TITORECT(tile, &sourceRect);
@@ -1086,7 +1119,7 @@ dbEraseNonSub(tile, cxp)
     GEOTRANSRECT(&scx->scx_trans, &sourceRect, &targetRect);
 
     /* Erase the substrate type from the area of this tile in the target plane. */
-    return DBNMPaintPlane(plane, type, &targetRect, DBStdEraseTbl(subType, pNum),
+    return DBNMPaintPlane(plane, newdinfo, &targetRect, DBStdEraseTbl(subType, pNum),
 		(PaintUndoInfo *)NULL);
 }
 
@@ -1098,8 +1131,9 @@ dbEraseNonSub(tile, cxp)
  */
 
 int
-dbCopySubFunc(tile, csd)
+dbCopySubFunc(tile, dinfo, csd)
     Tile *tile;			/* Pointer to tile to erase from target */
+    TileType dinfo;		/* Split tile information */
     struct dbCopySubData *csd;	/* Client data */
 {
     Rect rect;
@@ -1109,10 +1143,10 @@ dbCopySubFunc(tile, csd)
 
     plane = csd->csd_plane;
     pNum = csd->csd_pNum;
-    type = TiGetTypeExact(tile);
+    type = TiGetTypeExact(tile) | dinfo;
     if (IsSplit(tile))
     {
-	loctype = (SplitSide(tile)) ? SplitRightType(tile) : SplitLeftType(tile);
+	loctype = (dinfo & TT_SIDE) ? SplitRightType(tile) : SplitLeftType(tile);
 	if (loctype == TT_SPACE) return 0;
     }
     else
@@ -1433,8 +1467,9 @@ DBCellCopyLabels(scx, mask, xMask, targetUse, pArea)
  ***/
 
 int
-dbCopyManhattanPaint(tile, cxp)
-    Tile *tile;	/* Pointer to tile to copy */
+dbCopyManhattanPaint(tile, dinfo, cxp)
+    Tile *tile;			/* Pointer to tile to copy */
+    TileType dinfo;		/* Split tile information */
     TreeContext *cxp;		/* Context from DBTreeSrTiles */
 {
     SearchContext *scx = cxp->tc_scx;
@@ -1480,8 +1515,9 @@ dbCopyManhattanPaint(tile, cxp)
  ***/
 
 int
-dbCopyAllPaint(tile, cxp)
-    Tile *tile;	/* Pointer to tile to copy */
+dbCopyAllPaint(tile, dinfo, cxp)
+    Tile *tile;			/* Pointer to tile to copy */
+    TileType dinfo;		/* Split tile information */
     TreeContext *cxp;		/* Context from DBTreeSrTiles */
 {
     SearchContext *scx = cxp->tc_scx;
@@ -1489,7 +1525,7 @@ dbCopyAllPaint(tile, cxp)
     Rect sourceRect, targetRect;
     PaintUndoInfo ui;
     CellDef *def;
-    TileType type = TiGetTypeExact(tile);
+    TileType type = TiGetTypeExact(tile) | dinfo;
     int pNum = cxp->tc_plane;
     int result;
     TileTypeBitMask *typeMask;
@@ -1502,13 +1538,13 @@ dbCopyAllPaint(tile, cxp)
      */
 
     bool splittile = FALSE;
-    TileType dinfo = 0;
+    TileType newdinfo = 0;
 
     if (IsSplit(tile))
     {
 	splittile = TRUE;
-	dinfo = DBTransformDiagonal(type, &scx->scx_trans);
-	type = (SplitSide(tile)) ? SplitRightType(tile) :
+	newdinfo = DBTransformDiagonal(type, &scx->scx_trans);
+	type = (dinfo & TT_SIDE) ? SplitRightType(tile) :
 			SplitLeftType(tile);
     }
 
@@ -1568,7 +1604,7 @@ dbCopyAllPaint(tile, cxp)
 	Rect rrect, orect;
 	int np, i, j;
 
-	GrClipTriangle(&targetRect, &arg->caa_rect, TRUE, dinfo, points, &np);
+	GrClipTriangle(&targetRect, &arg->caa_rect, TRUE, newdinfo, points, &np);
 
 	if (np == 0)
 	   return(0);
@@ -1597,7 +1633,7 @@ dbCopyAllPaint(tile, cxp)
 		rrect.r_ybot = points[0].p_y;
 		rrect.r_ytop = points[2].p_y;
 		GeoCanonicalRect(&rrect, &targetRect);
-		dinfo = 0;
+		newdinfo = 0;
 	    }
 	    else if (np >= 4) /* Process extra rectangles in the area */
 	    {
@@ -1654,7 +1690,7 @@ topbottom:
 
 splitdone:
 
-    result = (*dbCurPaintPlane)(def, pNum, dinfo | type, &targetRect, &ui);
+    result = (*dbCurPaintPlane)(def, pNum, newdinfo | type, &targetRect, &ui);
     if ((result != 0) && (arg->caa_func != NULL))
     {
 	/* result == 1 used exclusively for DRC off-grid error flagging */

database/DBcellname.c

@@ -117,6 +117,14 @@ DBCellRename(cellname, newname, doforce)
 	return FALSE;
     }
 
+    /* Cannot rename a cell with the name of an existing cell */
+    entry = HashLookOnly(&dbCellDefTable, newname);
+    if (entry != NULL)
+    {
+	TxError("Cannot rename; cell \"%s\" already exists!\n",  newname);
+	return FALSE;
+    }
+
     /* Disallow renaming if the cell has the READONLY flag set,	*/
     /* because the cellname must match the name in the GDS	*/
     /* file referenced.						*/
@@ -144,10 +152,9 @@ DBCellRename(cellname, newname, doforce)
 
     if (doforce && ((celldef->cd_flags & CDVENDORGDS) == CDVENDORGDS))
     {
-	char *chkgdsfile;
 	bool isReadOnly;
 
-	chkgdsfile = (char *)DBPropGet(celldef, "GDS_FILE", &isReadOnly);
+	DBPropGet(celldef, "GDS_FILE", &isReadOnly);
 	/* Note that clearing GDS_FILE will also clear CDVENDORGDS flag */
 	if (isReadOnly) DBPropPut(celldef, "GDS_FILE", NULL);
 
@@ -288,7 +295,7 @@ DBCellDelete(cellname, force)
     if ((force == FALSE) &&
 	(celldef->cd_flags & (CDMODIFIED|CDBOXESCHANGED|CDSTAMPSCHANGED)))
     {
-	static char *yesno[] = { "no", "yes", 0 };
+	static const char *yesno[] = { "no", "yes", 0 };
 	int code;
 	char *prompt = TxPrintString("Cell %s has been modified.\n  Do you"
 		" want to delete it and lose all changes? ",
@@ -312,6 +319,7 @@ DBCellDelete(cellname, force)
     /* use.  If so, load the window with (UNNAMED).			*/
 
     UndoDisable();
+    free_magic1_t mm1 = freeMagic1_init();
     for (celluse = celldef->cd_parents; celluse != (CellUse *) NULL;
 	 	celluse = celluse->cu_nextuse)
     {
@@ -320,8 +328,9 @@ DBCellDelete(cellname, force)
 	    WindUnload(celluse);
 	    freeMagic(celluse->cu_id);
 	}
-	freeMagic((char *)celluse);
+	freeMagic1(&mm1, (char *)celluse);
     }
+    freeMagic1_end(&mm1);
     celldef->cd_parents = (CellUse *)NULL;
 
     DBWResetBox(celldef);
@@ -1610,7 +1619,9 @@ dbAbutmentUseFunc(selUse, use, transform, data)
 {
     Rect bbox, refbox;
     Transform *trans;
+    PropertyRecord *proprec;
     char *propvalue;
+    char *refllx, *reflly, *refurx, *refury;
     bool found;
     bool *dolist = (bool *)data;
 
@@ -1632,32 +1643,47 @@ dbAbutmentUseFunc(selUse, use, transform, data)
     }
 
     trans = &use->cu_transform;
-    propvalue = (char *)DBPropGet(use->cu_def, "FIXED_BBOX", &found);
+    proprec = DBPropGet(use->cu_def, "FIXED_BBOX", &found);
     if (!found)
 	bbox = use->cu_def->cd_bbox;
     else
     {
-	if (sscanf(propvalue, "%d %d %d %d", &bbox.r_xbot, &bbox.r_ybot,
-		&bbox.r_xtop, &bbox.r_ytop) != 4)
+	if ((proprec->prop_type == PROPERTY_TYPE_DIMENSION) &&
+		(proprec->prop_len == 4))
+	{
+	    bbox.r_xbot = proprec->prop_value.prop_integer[0];
+	    bbox.r_ybot = proprec->prop_value.prop_integer[1];
+	    bbox.r_xtop = proprec->prop_value.prop_integer[2];
+	    bbox.r_ytop = proprec->prop_value.prop_integer[3];
+	}
+	else
+	{
+	    TxError("Unable to parse the cell's FIXED_BBOX property; using "
+			"the instance bounding box instead.\n");
 	    bbox = use->cu_def->cd_bbox;
+	}
     }
     GeoTransRect(trans, &bbox, &refbox);
 
+    /* NOTE:  Ideally, the MagWindow pointer should get passed to this routine */
+    refllx = DBWPrintValue(refbox.r_xbot, (MagWindow *)NULL, TRUE);
+    reflly = DBWPrintValue(refbox.r_ybot, (MagWindow *)NULL, FALSE);
+    refurx = DBWPrintValue(refbox.r_xtop, (MagWindow *)NULL, TRUE);
+    refury = DBWPrintValue(refbox.r_ytop, (MagWindow *)NULL, FALSE);
+
 #ifdef MAGIC_WRAPPER
     if (*dolist)
     {
 	pobj = Tcl_NewListObj(0, NULL);
-	Tcl_ListObjAppendElement(magicinterp, pobj, Tcl_NewIntObj(refbox.r_xbot));
-	Tcl_ListObjAppendElement(magicinterp, pobj, Tcl_NewIntObj(refbox.r_ybot));
-	Tcl_ListObjAppendElement(magicinterp, pobj, Tcl_NewIntObj(refbox.r_xtop));
-	Tcl_ListObjAppendElement(magicinterp, pobj, Tcl_NewIntObj(refbox.r_ytop));
+	Tcl_ListObjAppendElement(magicinterp, pobj, Tcl_NewStringObj(refllx, -1));
+	Tcl_ListObjAppendElement(magicinterp, pobj, Tcl_NewStringObj(reflly, -1));
+	Tcl_ListObjAppendElement(magicinterp, pobj, Tcl_NewStringObj(refurx, -1));
+	Tcl_ListObjAppendElement(magicinterp, pobj, Tcl_NewStringObj(refury, -1));
 	Tcl_SetObjResult(magicinterp, pobj);
     }
     else
 #endif
-    TxPrintf("Abutment box:  %d %d %d %d\n", refbox.r_xbot, refbox.r_ybot,
-	    refbox.r_xtop, refbox.r_ytop);
-	
+    TxPrintf("Abutment box:  %s %s %s %s\n", refllx, reflly, refurx, refury);
     return 0;
 }
 
@@ -1936,6 +1962,7 @@ DBCellDeleteDef(cellDef)
     entry = HashFind(&dbCellDefTable, cellDef->cd_name);
     ASSERT(HashGetValue(entry) == (ClientData) cellDef, "DBCellDeleteDef");
     HashSetValue(entry, (ClientData) NULL);
+    HashRemove(&dbCellDefTable, cellDef->cd_name);
     if (cellDef->cd_props)
 	DBPropClearAll(cellDef);
 
@@ -1997,8 +2024,10 @@ DBCellDefFree(cellDef)
 	cellDef->cd_planes[pNum] = (Plane *) NULL;
     }
 
+    free_magic1_t mm1 = freeMagic1_init();
     for (lab = cellDef->cd_labels; lab; lab = lab->lab_next)
-	freeMagic((char *) lab);
+	freeMagic1(&mm1, (char *) lab);
+    freeMagic1_end(&mm1);
     SigEnableInterrupts();
     HashKill(&cellDef->cd_idHash);
 
@@ -2380,6 +2409,50 @@ DBGenerateUniqueIds(def, warn)
     HashKill(&dbUniqueNameTable);
 }
 
+/*
+ * ----------------------------------------------------------------------------
+ *
+ * DBSelectionUniqueIds --
+ *
+ * This is similar to DBGenerateUniqueIds(), but the purpose is to make
+ * sure that cell IDs in the selection do not collide with IDs in the
+ * definition.  This is done before copying from Select2Def back to the
+ * root edit CellDef.  Otherwise, any copied cell takes the name of the
+ * original, and the original gets renamed, which is unexpected behavior.
+ * Called only from SelectCopy().
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	May modify the use-id's of the cells in the cell plane of 'selDef'.
+ *
+ * ----------------------------------------------------------------------------
+ */
+
+void
+DBSelectionUniqueIds(selDef, rootDef)
+    CellDef *selDef;	/* Should be Select2Def */
+    CellDef *rootDef;	/* Should be EditRootDef */
+{
+    int dbFindNamesFunc();
+    int dbGenerateUniqueIdsFunc();
+
+    dbWarnUniqueIds = FALSE;
+    HashInit(&dbUniqueDefTable, 32, 1);		/* Indexed by (CellDef *) */
+    HashInit(&dbUniqueNameTable, 32, 0);	/* Indexed by use-id */
+
+    /* Build up tables of names */
+    DBCellEnum(rootDef, dbFindNamesFunc, (ClientData) rootDef);
+    DBCellEnum(selDef, dbFindNamesFunc, (ClientData) selDef);
+
+    /* Assign unique use-ids to all cells in the selection  */
+    DBCellEnum(selDef, dbGenerateUniqueIdsFunc, (ClientData) selDef);
+
+    HashKill(&dbUniqueDefTable);
+    HashKill(&dbUniqueNameTable);
+}
+
 /*
  * ----------------------------------------------------------------------------
  *

database/DBcellsrch.c

@@ -83,13 +83,15 @@ struct seeTypesArg
  */
 
 int
-DBSrCellPlaneArea(BPlane *plane, Rect *rect, int (*func)(), ClientData arg)
+DBSrCellPlaneArea(BPlane *plane, const Rect *rect, int (*func)(), ClientData arg)
 {
+    BPEnum sbpe;
     BPEnum *bpe;
     CellUse *use;
     int rval = 0;
 
-    bpe = (BPEnum *)mallocMagic(sizeof(BPEnum));
+    /* bpe = (BPEnum *)mallocMagic(sizeof(BPEnum)); */
+    bpe = &sbpe;
     BPEnumInit(bpe, plane, rect, BPE_OVERLAP, "DBSrCellPlaneArea");
 
     while ((use = BPEnumNext(bpe)))
@@ -102,7 +104,7 @@ DBSrCellPlaneArea(BPlane *plane, Rect *rect, int (*func)(), ClientData arg)
     }
 
     BPEnumTerm(bpe);
-    freeMagic(bpe);
+    /* freeMagic(bpe); */
     return rval;
 }
 
@@ -118,6 +120,7 @@ DBSrCellPlaneArea(BPlane *plane, Rect *rect, int (*func)(), ClientData arg)
  *	int
  *	func(tile, cxp)
  *	    Tile *tile;
+ *	    TileType dinfo;
  *	    TreeContext *cxp;
  *	{
  *	}
@@ -414,6 +417,7 @@ dbCellUniqueTileSrFunc(scx, fp)
  *	int
  *	func(tile, cxp)
  *	    Tile *tile;
+ *	    TileType dinfo;
  *	    TreeContext *cxp;
  *	{
  *	}
@@ -584,6 +588,25 @@ DBTreeSrLabels(scx, mask, xMask, tpath, flags, func, cdarg)
 	if (!DBCellRead(def, TRUE, TRUE, NULL))
 	    return 0;
 
+    if (flags & TF_LABEL_REVERSE_SEARCH)
+    {
+	/* Search children first */
+	filter.tf_func = func;
+	filter.tf_arg = cdarg;
+	filter.tf_mask = mask;
+	filter.tf_xmask = xMask;
+	filter.tf_tpath = tpath;
+	filter.tf_flags = flags;
+
+	scx2 = *scx;
+	if (scx2.scx_area.r_xbot > TiPlaneRect.r_xbot) scx2.scx_area.r_xbot -= 1;
+	if (scx2.scx_area.r_ybot > TiPlaneRect.r_ybot) scx2.scx_area.r_ybot -= 1;
+	if (scx2.scx_area.r_xtop < TiPlaneRect.r_xtop) scx2.scx_area.r_xtop += 1;
+	if (scx2.scx_area.r_ytop < TiPlaneRect.r_ytop) scx2.scx_area.r_ytop += 1;
+	if (DBCellSrArea(&scx2, dbCellLabelSrFunc, (ClientData) &filter))
+	    return 1;
+    }
+
     for (lab = def->cd_labels; lab; lab = lab->lab_next)
     {
 	if (SigInterruptPending) break;
@@ -636,6 +659,8 @@ DBTreeSrLabels(scx, mask, xMask, tpath, flags, func, cdarg)
 		return (1);
     }
 
+    if (flags & TF_LABEL_REVERSE_SEARCH) return 0;  /* children already searched */
+
     filter.tf_func = func;
     filter.tf_arg = cdarg;
     filter.tf_mask = mask;
@@ -677,7 +702,7 @@ dbCellLabelSrFunc(scx, fp)
 {
     Label *lab;
     Rect *r = &scx->scx_area;
-    TileTypeBitMask *mask = fp->tf_mask;
+    const TileTypeBitMask *mask = fp->tf_mask;
     CellDef *def = scx->scx_use->cu_def;
     char *tnext;
     int result;
@@ -707,6 +732,16 @@ dbCellLabelSrFunc(scx, fp)
 	}
     }
 
+    /* If fp->tf_flags has TF_LABEL_REVERSE_SEARCH, then search child
+     * uses first, then the parent.  This is for display, so that if
+     * a child cell and parent cell have overlapping labels, the parent
+     * label is the one on top.
+     */
+
+    if (fp->tf_flags & TF_LABEL_REVERSE_SEARCH)
+	if (DBCellSrArea(scx, dbCellLabelSrFunc, (ClientData) fp))
+	    result = 1;
+
     /* Apply the function first to any of the labels in this def. */
 
     result = 0;
@@ -728,9 +763,11 @@ dbCellLabelSrFunc(scx, fp)
 	}
     }
 
-    /* Now visit each child use recursively */
-    if (DBCellSrArea(scx, dbCellLabelSrFunc, (ClientData) fp))
-	result = 1;
+    /* Now visit each child use recursively, if not doing a reverse search */
+
+    if (!(fp->tf_flags & TF_LABEL_REVERSE_SEARCH))
+	if (DBCellSrArea(scx, dbCellLabelSrFunc, (ClientData) fp))
+	    result = 1;
 
 cleanup:
     /* Remove the trailing pathname component from the TerminalPath */
@@ -912,8 +949,9 @@ DBSeeTypesAll(rootUse, rootRect, xMask, mask)
  */
 
 int
-dbSeeTypesAllSrFunc(tile, cxp)
+dbSeeTypesAllSrFunc(tile, dinfo, cxp)
     Tile *tile;
+    TileType dinfo;
     TreeContext *cxp;
 {
     Rect tileRect;
@@ -924,7 +962,7 @@ dbSeeTypesAllSrFunc(tile, cxp)
     if (GEO_OVERLAP((&tileRect), area))
     {
 	if (IsSplit(tile))
-	    TTMaskSetType(mask, SplitSide(tile) ?
+	    TTMaskSetType(mask, (dinfo & TT_SIDE) ?
 			SplitRightType(tile) : SplitLeftType(tile));
         else
 	    TTMaskSetType(mask, TiGetType(tile));
@@ -1514,19 +1552,22 @@ DBScaleEverything(scalen, scaled)
     }
 
     /* Free the linked CellDef list */
-
+    free_magic1_t mm1 = freeMagic1_init();
     lcd = lhead;
     while (lcd != NULL)
     {
-	freeMagic((char *)lcd);
+	freeMagic1(&mm1, (char *)lcd);
 	lcd = lcd->cd_next;
     }
+    freeMagic1_end(&mm1);
 
     /* Scale all elements */
     DBWScaleElements(scalen, scaled);
 
+#ifdef ROUTE_MODULE
     /* Recovery of global plane pointers */
     MZAttachHintPlanes();
+#endif
 
     /* Modify root box */
     ToolScaleBox(scalen, scaled);
@@ -1602,8 +1643,9 @@ dbScalePlane(oldplane, newplane, pnum, scalen, scaled, doCIF)
  */
 
 int
-dbTileScaleFunc(tile, scvals)
+dbTileScaleFunc(tile, dinfo, scvals)
     Tile *tile;
+    TileType dinfo;
     struct scaleArg *scvals;
 {
     TileType type;
@@ -1626,12 +1668,15 @@ dbTileScaleFunc(tile, scvals)
 	return 0;
     }
 
-    type = TiGetTypeExact(tile);
+    type = TiGetTypeExact(tile) | dinfo;
     exact = type;
     if (IsSplit(tile))
-	type = (SplitSide(tile)) ? SplitRightType(tile) : SplitLeftType(tile);
+	type = (dinfo & TT_SIDE) ? SplitRightType(tile) : SplitLeftType(tile);
     DBNMPaintPlane(scvals->ptarget, exact, &targetRect,
-		((scvals->doCIF) ? CIFPaintTable :
+		(
+#ifdef CIF_MODULE
+		(scvals->doCIF) ? CIFPaintTable :
+#endif
 		DBStdPaintTbl(type, scvals->pnum)),
 		(PaintUndoInfo *)NULL);
     return 0;
@@ -1681,8 +1726,9 @@ dbMovePlane(oldplane, newplane, pnum, origx, origy)
  */
 
 int
-dbTileMoveFunc(tile, mvvals)
+dbTileMoveFunc(tile, dinfo, mvvals)
     Tile *tile;
+    TileType dinfo;
     struct moveArg *mvvals;
 {
     TileType type;
@@ -1695,12 +1741,12 @@ dbTileMoveFunc(tile, mvvals)
     DBMovePoint(&targetRect.r_ll, mvvals->origx, mvvals->origy);
     DBMovePoint(&targetRect.r_ur, mvvals->origx, mvvals->origy);
 
-    type = TiGetTypeExact(tile);
+    type = TiGetTypeExact(tile) | dinfo;
     exact = type;
     if (IsSplit(tile))
-	type = (SplitSide(tile)) ? SplitRightType(tile) : SplitLeftType(tile);
+	type = (dinfo & TT_SIDE) ? SplitRightType(tile) : SplitLeftType(tile);
     DBNMPaintPlane(mvvals->ptarget, exact, &targetRect,
-		DBStdPaintTbl(type, mvvals->pnum),
+		(mvvals->pnum < 0) ? CIFPaintTable : DBStdPaintTbl(type, mvvals->pnum),
 		(PaintUndoInfo *)NULL);
     return 0;
 }
@@ -1762,12 +1808,14 @@ DBSrCellUses(cellDef, func, arg)
     }
 
     /* Free this linked cellUse structure */
+    free_magic1_t mm1 = freeMagic1_init();
     lu = luhead;
     while (lu != NULL)
     {
-	freeMagic((char *)lu);
+	freeMagic1(&mm1, (char *)lu);
 	lu = lu->cu_next;
     }
+    freeMagic1_end(&mm1);
     return retval;
 }
 
@@ -1791,84 +1839,48 @@ typedef struct _cellpropstruct {
  * ----------------------------------------------------------------------------
  */
 
-int dbScaleProp(name, value, cps)
+int dbScaleProp(name, proprec, cps)
     char *name;
-    char *value;
+    PropertyRecord *proprec;
     CellPropStruct *cps;
 {
-    int scalen, scaled;
-    char *newvalue, *vptr;
-    Rect r;
+    int i, scalen, scaled;
+    Point p;
 
-    if ((strlen(name) > 5) && !strncmp(name + strlen(name) - 5, "_BBOX", 5))
+    /* Only "dimension" and "plane" type properties get scaled */
+
+    if (proprec->prop_type == PROPERTY_TYPE_PLANE)
     {
-	if (sscanf(value, "%d %d %d %d", &r.r_xbot, &r.r_ybot,
-			&r.r_xtop, &r.r_ytop) == 4)
-	{
-	    /* Scale numerator held in point X value, */
-	    /* scale denominator held in point Y value */
-
-	    scalen = cps->cps_point.p_x;
-	    scaled = cps->cps_point.p_y;
-
-	    DBScalePoint(&r.r_ll, scalen, scaled);
-	    DBScalePoint(&r.r_ur, scalen, scaled);
-
-	    newvalue = (char *)mallocMagic(40);
-	    sprintf(newvalue, "%d %d %d %d", r.r_xbot, r.r_ybot,
-			r.r_xtop, r.r_ytop);
-	    DBPropPut(cps->cps_def, name, newvalue);
-	}
+	Plane *newplane;
+	newplane = DBNewPlane((ClientData)TT_SPACE);
+	DBClearPaintPlane(newplane);
+	/* Plane index is unused;  arbitrarily substitute -1 */
+	dbScalePlane(proprec->prop_value.prop_plane, newplane, -1,
+			scalen, scaled, TRUE);
+	DBFreePaintPlane(proprec->prop_value.prop_plane);
+	TiFreePlane(proprec->prop_value.prop_plane);
+	proprec->prop_value.prop_plane = newplane;
+	return 0;
     }
-    else if (!strncmp(name, "MASKHINTS_", 10))
+
+    if (proprec->prop_type != PROPERTY_TYPE_DIMENSION) return 0; 
+
+    /* Scale numerator held in point X value, */
+    /* scale denominator held in point Y value */
+    scalen = cps->cps_point.p_x;
+    scaled = cps->cps_point.p_y;
+
+    for (i = 0; i < proprec->prop_len; i += 2)
     {
-	char *vptr, *lastval;
-	int lastlen;
+	if ((i + 1) >= proprec->prop_len) break;
 
-	newvalue = (char *)NULL;
-	vptr = value;
-	while (*vptr != '\0')
-	{
-	    if (sscanf(vptr, "%d %d %d %d", &r.r_xbot, &r.r_ybot,
-			&r.r_xtop, &r.r_ytop) == 4)
-	    {
-	    	/* Scale numerator held in point X value, */
-	    	/* scale denominator held in point Y value */
-
-	    	scalen = cps->cps_point.p_x;
-	    	scaled = cps->cps_point.p_y;
-
-	    	DBScalePoint(&r.r_ll, scalen, scaled);
-	    	DBScalePoint(&r.r_ur, scalen, scaled);
-
-		lastval = newvalue;
-		lastlen = (lastval) ? strlen(lastval) : 0;
-		newvalue = mallocMagic(40 + lastlen);
-
-		if (lastval)
-		    strcpy(newvalue, lastval);
-		else
-		    *newvalue = '\0';
-
-		sprintf(newvalue + lastlen, "%s%d %d %d %d", (lastval) ? " " : "",
-			r.r_xbot, r.r_ybot, r.r_xtop, r.r_ytop);
-		if (lastval) freeMagic(lastval);
-
-		/* Parse through the four values and check if there's more */
-                while (*vptr && !isspace(*vptr)) vptr++;
-                while (*vptr && isspace(*vptr)) vptr++;
-                while (*vptr && !isspace(*vptr)) vptr++;
-                while (*vptr && isspace(*vptr)) vptr++;
-                while (*vptr && !isspace(*vptr)) vptr++;
-                while (*vptr && isspace(*vptr)) vptr++;
-                while (*vptr && !isspace(*vptr)) vptr++;
-                while (*vptr && isspace(*vptr)) vptr++;
-	    }
-	    else break;
-	}
-	if (newvalue)
-	    DBPropPut(cps->cps_def, name, newvalue);
+	p.p_x = proprec->prop_value.prop_integer[i];
+	p.p_y = proprec->prop_value.prop_integer[i + 1];
+	DBScalePoint(&p, scalen, scaled);
+	proprec->prop_value.prop_integer[i] = p.p_x;
+	proprec->prop_value.prop_integer[i + 1] = p.p_y;
     }
+
     return 0;	/* Keep enumerating through properties */
 }
 
@@ -1884,33 +1896,47 @@ int dbScaleProp(name, value, cps)
  * ----------------------------------------------------------------------------
  */
 
-int dbMoveProp(name, value, cps)
+int dbMoveProp(name, proprec, cps)
     char *name;
-    char *value;
+    PropertyRecord *proprec;
     CellPropStruct *cps;
 {
-    int origx, origy;
+    int i, origx, origy;
     char *newvalue;
-    Rect r;
+    Point p;
 
-    if (((strlen(name) > 5) && !strncmp(name + strlen(name) - 5, "_BBOX", 5))
-		|| !strncmp(name, "MASKHINTS_", 10))
+    /* Only "dimension" and "plane" type properties get scaled */
+
+    if (proprec->prop_type == PROPERTY_TYPE_PLANE)
     {
-	if (sscanf(value, "%d %d %d %d", &r.r_xbot, &r.r_ybot,
-			&r.r_xtop, &r.r_ytop) == 4)
-	{
-	    origx = cps->cps_point.p_x;
-	    origy = cps->cps_point.p_y;
+	Plane *newplane;
 
-	    DBMovePoint(&r.r_ll, origx, origy);
-	    DBMovePoint(&r.r_ur, origx, origy);
-
-	    newvalue = (char *)mallocMagic(40);
-	    sprintf(newvalue, "%d %d %d %d", r.r_xbot, r.r_ybot,
-			r.r_xtop, r.r_ytop);
-	    DBPropPut(cps->cps_def, name, newvalue);
-	}
+	newplane = DBNewPlane((ClientData) TT_SPACE);
+	DBClearPaintPlane(newplane);
+	/* Use plane index -1 to indicate use of CIFPaintTable */
+	dbMovePlane(proprec->prop_value.prop_plane, newplane, -1, origx, origy);
+        DBFreePaintPlane(proprec->prop_value.prop_plane);
+	TiFreePlane(proprec->prop_value.prop_plane);
+        proprec->prop_value.prop_plane = newplane;
+	return 0;
     }
+
+    if (proprec->prop_type != PROPERTY_TYPE_DIMENSION) return 0; 
+
+    origx = cps->cps_point.p_x;
+    origy = cps->cps_point.p_y;
+
+    for (i = 0; i < proprec->prop_len; i += 2)
+    {
+	if ((i + 1) >= proprec->prop_len) break;
+
+	p.p_x = proprec->prop_value.prop_integer[i];
+	p.p_y = proprec->prop_value.prop_integer[i + 1];
+	DBMovePoint(&p, origx, origy);
+	proprec->prop_value.prop_integer[i] = p.p_x;
+	proprec->prop_value.prop_integer[i + 1] = p.p_y;
+    }
+
     return 0;	/* Keep enumerating through properties */
 }
 
@@ -1995,12 +2021,14 @@ dbScaleCell(cellDef, scalen, scaled)
     BPFree(cellPlaneOrig);
 
     /* Free this linked cellUse structure */
+    free_magic1_t mm1 = freeMagic1_init();
     lu = luhead;
     while (lu != NULL)
     {
-	freeMagic((char *)lu);
+	freeMagic1(&mm1, (char *)lu);
 	lu = lu->cu_next;
     }
+    freeMagic1_end(&mm1);
 
     /* Scale all of the paint tiles in this cell by creating a new plane */
     /* and copying all tiles into the new plane at scaled dimensions.	 */
@@ -2203,12 +2231,14 @@ DBMoveCell(cellDef, origx, origy)
     BPFree(cellPlaneOrig);
 
     /* Free this linked cellUse structure */
+    free_magic1_t mm1 = freeMagic1_init();
     lu = luhead;
     while (lu != NULL)
     {
-	freeMagic((char *)lu);
+	freeMagic1(&mm1, (char *)lu);
 	lu = lu->cu_next;
     }
+    freeMagic1_end(&mm1);
 
     /* Move all of the paint tiles in this cell by creating a new plane */
     /* and copying all tiles into the new plane at the new position.	 */

database/DBcellsubr.c

@@ -218,8 +218,10 @@ DBCellClearDef(cellDef)
     cellDef->cd_bbox.r_xtop = cellDef->cd_bbox.r_ytop = 1;
     cellDef->cd_extended.r_xbot = cellDef->cd_extended.r_ybot = 0;
     cellDef->cd_extended.r_xtop = cellDef->cd_extended.r_ytop = 1;
+    free_magic1_t mm1 = freeMagic1_init();
     for (lab = cellDef->cd_labels; lab; lab = lab->lab_next)
-	freeMagic((char *) lab);
+	freeMagic1(&mm1, (char *) lab);
+    freeMagic1_end(&mm1);
     cellDef->cd_labels = (Label *) NULL;
     cellDef->cd_lastLabel = (Label *) NULL;
 
@@ -262,7 +264,7 @@ DBClearPaintPlane(plane)
 
     /* Allocate a new central space tile */
     newCenterTile = TiAlloc();
-    plane->pl_hint = newCenterTile;
+    PlaneSetHint(plane, newCenterTile);
     TiSetBody(newCenterTile, TT_SPACE);
     dbSetPlaneTile(plane, newCenterTile);
 }

database/DBconnect.c

@@ -128,86 +128,6 @@ DBInvTransformDiagonal(oldtype, trans)
     return dinfo;
 }
 
-
-/*
- * ----------------------------------------------------------------------------
- *
- * DBSrConnectOnePlane --
- *
- * 	Search from a starting tile to find all paint that is electrically
- *	connected to that tile in the same plane.
- *
- * Results:
- *	0 is returned if the search finished normally.  1 is returned
- *	if the search was aborted.
- *
- * Side effects:
- *	For every paint tile that is electrically connected to the initial
- *	tile, func is called.  Func should have the following form:
- *
- *	    int
- *	    func(tile, clientData)
- *		Tile *tile;
- *		ClientData clientData;
- *    	    {
- *	    }
- *
- *	The clientData passed to func is the same one that was passed
- *	to us.  Func returns 0 under normal conditions;  if it returns
- *	1 then the search is aborted.
- *
- *				*** WARNING ***
- *
- *	Func should not modify any paint during the search, since this
- *	will mess up pointers kept by these procedures and likely cause
- *	a core-dump.
- *
- * ----------------------------------------------------------------------------
- */
-
-int
-DBSrConnectOnePlane(startTile, connect, func, clientData)
-    Tile *startTile;		/* Starting tile for search */
-    TileTypeBitMask *connect;	/* Pointer to a table indicating what tile
-				 * types connect to what other tile types.
-				 * Each entry gives a mask of types that
-				 * connect to tiles of a given type.
-				 */
-    int (*func)();		/* Function to apply at each connected tile. */
-    ClientData clientData;	/* Client data for above function. */
-
-{
-    struct conSrArg csa;
-    int result;
-    extern int dbSrConnectFunc();	/* Forward declaration. */
-
-    result = 0;
-    csa.csa_def = (CellDef *)NULL;
-    csa.csa_bounds = TiPlaneRect;
-
-    /* Pass 1.  During this pass the client function gets called. */
-
-    csa.csa_clientFunc = func;
-    csa.csa_clientData = clientData;
-    csa.csa_clientDefault = startTile->ti_client;
-    csa.csa_clear = FALSE;
-    csa.csa_connect = connect;
-    csa.csa_pNum = -1;
-    if (dbSrConnectFunc(startTile, &csa) != 0) result = 1;
-
-    /* Pass 2.  Don't call any client function, just clear the marks.
-     * Don't allow any interruptions.
-     */
-
-    SigDisableInterrupts();
-    csa.csa_clientFunc = NULL;
-    csa.csa_clear = TRUE;
-    (void) dbSrConnectFunc(startTile, &csa);
-    SigEnableInterrupts();
-
-    return result;
-}
-
 /*
  * ----------------------------------------------------------------------------
  *
@@ -277,9 +197,7 @@ DBSrConnect(def, startArea, mask, connect, bounds, func, clientData)
 {
     struct conSrArg csa;
     int startPlane, result;
-    Tile *startTile;			/* Starting tile for search. */
-    extern int dbSrConnectFunc();	/* Forward declaration. */
-    extern int dbSrConnectStartFunc();
+    TileAndDinfo start_tad;	/* Starting tile and split information */
 
     result = 0;
     csa.csa_def = def;
@@ -290,17 +208,18 @@ DBSrConnect(def, startArea, mask, connect, bounds, func, clientData)
      * the tile address and returns.
      */
 
-    startTile = NULL;
+    start_tad.tad_tile = NULL;
+    start_tad.tad_next = NULL;  /* unused */
     for (startPlane = PL_TECHDEPBASE; startPlane < DBNumPlanes; startPlane++)
     {
     	csa.csa_pNum = startPlane;
 	if (DBSrPaintArea((Tile *) NULL,
 	    def->cd_planes[startPlane], startArea, mask,
-	    dbSrConnectStartFunc, (ClientData) &startTile) != 0) break;
+	    dbSrConnectStartFunc, PTR2CD(&start_tad)) != 0) break;
     }
-    if (startTile == NULL) return 0;
+    if (start_tad.tad_tile == NULL) return 0;
     /* The following lets us call DBSrConnect recursively */
-    else if (startTile->ti_client == (ClientData)1) return 0;
+    else if (start_tad.tad_tile->ti_client == (ClientData)1) return 0;
 
     /* Pass 1.  During this pass the client function gets called. */
 
@@ -309,7 +228,8 @@ DBSrConnect(def, startArea, mask, connect, bounds, func, clientData)
     csa.csa_clientDefault = CLIENTDEFAULT;
     csa.csa_clear = FALSE;
     csa.csa_connect = connect;
-    if (dbSrConnectFunc(startTile, &csa) != 0) result = 1;
+    if (dbSrConnectFunc(start_tad.tad_tile, start_tad.tad_dinfo,
+			PTR2CD(&csa)) != 0) result = 1;
 
     /* Pass 2.  Don't call any client function, just clear the marks.
      * Don't allow any interruptions.
@@ -318,18 +238,22 @@ DBSrConnect(def, startArea, mask, connect, bounds, func, clientData)
     SigDisableInterrupts();
     csa.csa_clientFunc = NULL;
     csa.csa_clear = TRUE;
-    (void) dbSrConnectFunc(startTile, &csa);
+    (void) dbSrConnectFunc(start_tad.tad_tile, start_tad.tad_dinfo, PTR2CD(&csa));
     SigEnableInterrupts();
 
     return result;
 }
 
+/** @typedef cb_database_srpaintarea_t */
 int
-dbSrConnectStartFunc(tile, pTile)
-    Tile *tile;			/* This will be the starting tile. */
-    Tile **pTile;		/* We store tile's address here. */
+dbSrConnectStartFunc(
+    Tile *tile,		/* This will be the starting tile. */
+    TileType dinfo,	/* (unused) */
+    ClientData cdata)	/* We store tile and split info here. */
 {
-    *pTile = tile;
+    TileAndDinfo *tad = (TileAndDinfo *)CD2PTR(cdata);
+    tad->tad_tile = tile;
+    tad->tad_dinfo = dinfo;
     return 1;
 }
 
@@ -367,9 +291,7 @@ DBSrConnectOnePass(def, startArea, mask, connect, bounds, func, clientData)
 {
     struct conSrArg csa;
     int startPlane, result;
-    Tile *startTile;			/* Starting tile for search. */
-    extern int dbSrConnectFunc();	/* Forward declaration. */
-    extern int dbSrConnectStartFunc();
+    TileAndDinfo tad;
 
     result = 0;
     csa.csa_def = def;
@@ -380,17 +302,18 @@ DBSrConnectOnePass(def, startArea, mask, connect, bounds, func, clientData)
      * the tile address and returns.
      */
 
-    startTile = NULL;
+    tad.tad_tile = NULL;
+    tad.tad_next = NULL;   /* unused */
     for (startPlane = PL_TECHDEPBASE; startPlane < DBNumPlanes; startPlane++)
     {
     	csa.csa_pNum = startPlane;
 	if (DBSrPaintArea((Tile *) NULL,
 	    def->cd_planes[startPlane], startArea, mask,
-	    dbSrConnectStartFunc, (ClientData) &startTile) != 0) break;
+	    dbSrConnectStartFunc, PTR2CD(&tad)) != 0) break;
     }
-    if (startTile == NULL) return 0;
+    if (tad.tad_tile == NULL) return 0;
     /* The following lets us call DBSrConnect recursively */
-    else if (startTile->ti_client == (ClientData)1) return 0;
+    else if (tad.tad_tile->ti_client == (ClientData)1) return 0;
 
     /* Pass 1.  During this pass the client function gets called. */
 
@@ -399,7 +322,7 @@ DBSrConnectOnePass(def, startArea, mask, connect, bounds, func, clientData)
     csa.csa_clientDefault = CLIENTDEFAULT;
     csa.csa_clear = FALSE;
     csa.csa_connect = connect;
-    if (dbSrConnectFunc(startTile, &csa) != 0) result = 1;
+    if (dbSrConnectFunc(tad.tad_tile, tad.tad_dinfo, PTR2CD(&csa)) != 0) result = 1;
 
     return result;
 }
@@ -422,12 +345,15 @@ DBSrConnectOnePass(def, startArea, mask, connect, bounds, func, clientData)
  */
 
 int
-dbcFindTileFunc(tile, arg)
+dbcFindTileFunc(tile, dinfo, arg)
     Tile *tile;
+    TileType dinfo;
     ClientData arg;
 {
-    Tile **tptr = (Tile **)arg;
-    *tptr = tile;
+    TileAndDinfo *tad = (TileAndDinfo *)arg;
+
+    tad->tad_tile = tile;
+    tad->tad_dinfo = dinfo;
     return 1;
 }
 
@@ -465,16 +391,19 @@ dbcFindTileFunc(tile, arg)
  */
 
 int
-dbSrConnectFunc(tile, csa)
-    Tile *tile;			/* Tile that is connected. */
-    struct conSrArg *csa;	/* Contains information about the search. */
+dbSrConnectFunc(
+    Tile *tile,		/* Tile that is connected. */
+    TileType dinfo,	/* Split tile information */
+    ClientData cdata)	/* Contains information about the search. */
+			/* (struct conSrArg *csa) */
 {
+    struct conSrArg *csa = (struct conSrArg *)CD2PTR(cdata);
     Tile *t2;
     Rect tileArea;
     int i, pNum;
     int result = 0;
     bool callClient;
-    TileTypeBitMask *connectMask;
+    const TileTypeBitMask *connectMask;
     TileType loctype, checktype;
     PlaneMask planes;
 
@@ -484,11 +413,13 @@ dbSrConnectFunc(tile, csa)
     /* Drop the first entry on the stack */
     pNum = csa->csa_pNum;
     STACKPUSH(INT2CD(tile), dbConnectStack);
+    STACKPUSH(INT2CD(dinfo), dbConnectStack);
     STACKPUSH(INT2CD(pNum), dbConnectStack);
 
     while (!StackEmpty(dbConnectStack))
     {
 	pNum = (int)CD2INT(STACKPOP(dbConnectStack));
+	dinfo = (int)CD2INT(STACKPOP(dbConnectStack));
 	tile = (Tile *)CD2INT(STACKPOP(dbConnectStack));
 	if (result == 1) continue;
 
@@ -522,7 +453,7 @@ dbSrConnectFunc(tile, csa)
 
 	if (callClient && (csa->csa_clientFunc != NULL))
 	{
-	    if ((*csa->csa_clientFunc)(tile, pNum, csa->csa_clientData) != 0)
+	    if ((*csa->csa_clientFunc)(tile, dinfo, pNum, csa->csa_clientData) != 0)
 	    {
 		result = 1;
 		continue;
@@ -536,7 +467,7 @@ dbSrConnectFunc(tile, csa)
 
 	if (IsSplit(tile))
 	{
-	    if (SplitSide(tile))
+	    if (dinfo & TT_SIDE)
 		loctype = SplitRightType(tile);
 	    else
 		loctype = SplitLeftType(tile);
@@ -547,7 +478,7 @@ dbSrConnectFunc(tile, csa)
 
 	/* Left side: */
 
-	if (IsSplit(tile) && SplitSide(tile)) goto bottomside;
+	if (IsSplit(tile) && (dinfo & TT_SIDE)) goto bottomside;
 
 	for (t2 = BL(tile); BOTTOM(t2) < tileArea.r_ytop; t2 = RT(t2))
 	{
@@ -564,9 +495,11 @@ dbSrConnectFunc(tile, csa)
 		    if (t2->ti_client == csa->csa_clientDefault) continue;
 		}
 		else if (t2->ti_client == (ClientData) 1) continue;
-		if (IsSplit(t2))
-		    TiSetBody(t2, INT2CD(CD2INT(t2->ti_body) | TT_SIDE)); /* bit set */
 		STACKPUSH(INT2CD(t2), dbConnectStack);
+		if (IsSplit(t2))
+		    STACKPUSH(INT2CD((TileType)TT_SIDE), dbConnectStack);
+		else
+		    STACKPUSH(INT2CD(0), dbConnectStack);
 		STACKPUSH(INT2CD(pNum), dbConnectStack);
 	    }
 	}
@@ -574,7 +507,7 @@ dbSrConnectFunc(tile, csa)
 	/* Bottom side: */
 
 bottomside:
-	if (IsSplit(tile) && (!(SplitSide(tile) ^ SplitDirection(tile))))
+	if (IsSplit(tile) && ((!((dinfo & TT_SIDE) ? 1 : 0)) ^ SplitDirection(tile)))
 	    goto rightside;
 
 	for (t2 = LB(tile); LEFT(t2) < tileArea.r_xtop; t2 = TR(t2))
@@ -592,16 +525,17 @@ bottomside:
 		    if (t2->ti_client == csa->csa_clientDefault) continue;
 		}
 		else if (t2->ti_client == (ClientData) 1) continue;
+		STACKPUSH(INT2CD(t2), dbConnectStack);
 		if (IsSplit(t2))
 		{
 		    if (SplitDirection(t2))
-			/* bit set */
-			TiSetBody(t2, INT2CD(CD2INT(t2->ti_body) | TT_SIDE));
+			STACKPUSH(INT2CD((TileType)TT_SIDE), dbConnectStack);
 		    else
 			/* bit clear */
-			TiSetBody(t2, INT2CD(CD2INT(t2->ti_body) & ~TT_SIDE));
+			STACKPUSH(INT2CD(0), dbConnectStack);
 		}
-		STACKPUSH(INT2CD(t2), dbConnectStack);
+		else
+		    STACKPUSH(INT2CD(0), dbConnectStack);
 		STACKPUSH(INT2CD(pNum), dbConnectStack);
 	    }
 	}
@@ -609,7 +543,7 @@ bottomside:
 	/* Right side: */
 
 rightside:
-	if (IsSplit(tile) && !SplitSide(tile)) goto topside;
+	if (IsSplit(tile) && !(dinfo & TT_SIDE)) goto topside;
 
 	for (t2 = TR(tile); ; t2 = LB(t2))
 	{
@@ -626,9 +560,8 @@ rightside:
 		    if (t2->ti_client == csa->csa_clientDefault) goto nextRight;
 		}
 		else if (t2->ti_client == (ClientData) 1) goto nextRight;
-		if (IsSplit(t2))
-		    TiSetBody(t2, INT2CD(CD2INT(t2->ti_body) & ~TT_SIDE)); /* bit clear */
 		STACKPUSH(INT2CD(t2), dbConnectStack);
+		STACKPUSH(INT2CD(0), dbConnectStack);
 		STACKPUSH(INT2CD(pNum), dbConnectStack);
 	    }
 	    nextRight: if (BOTTOM(t2) <= tileArea.r_ybot) break;
@@ -637,7 +570,8 @@ rightside:
 	/* Top side: */
 topside:
 
-	if (IsSplit(tile) && (SplitSide(tile) ^ SplitDirection(tile))) goto donesides;
+	if (IsSplit(tile) && (((dinfo & TT_SIDE) ? 1 : 0) ^ SplitDirection(tile)))
+	    goto donesides;
 
 	for (t2 = RT(tile); ; t2 = BL(t2))
 	{
@@ -654,16 +588,18 @@ topside:
 		    if (t2->ti_client == csa->csa_clientDefault) goto nextTop;
 		}
 		else if (t2->ti_client == (ClientData) 1) goto nextTop;
+		STACKPUSH(INT2CD(t2), dbConnectStack);
 		if (IsSplit(t2))
 		{
 		    if (SplitDirection(t2))
 			/* bit clear */
-			TiSetBody(t2, INT2CD(CD2INT(t2->ti_body) & ~TT_SIDE));
+			STACKPUSH(INT2CD(0), dbConnectStack);
 		    else
 			/* bit set */
-			TiSetBody(t2, INT2CD(CD2INT(t2->ti_body) | TT_SIDE));
+			STACKPUSH(INT2CD((TileType)TT_SIDE), dbConnectStack);
 		}
-		STACKPUSH(INT2CD(t2), dbConnectStack);
+		else
+		    STACKPUSH(INT2CD(0), dbConnectStack);
 		STACKPUSH(INT2CD(pNum), dbConnectStack);
 	    }
 	    nextTop: if (LEFT(t2) <= tileArea.r_xbot) break;
@@ -682,6 +618,7 @@ donesides:
 	{
 	    Rect newArea;
 	    GEO_EXPAND(&tileArea, 1, &newArea);
+	    TileAndDinfo tad;
 
 	    for (i = PL_TECHDEPBASE; i < DBNumPlanes; i++)
 	    {
@@ -689,18 +626,20 @@ donesides:
 		if (IsSplit(tile))
 		{
 		    if (DBSrPaintNMArea((Tile *) NULL, csa->csa_def->cd_planes[i],
-				TiGetTypeExact(tile), &newArea, connectMask,
-				dbcFindTileFunc, (ClientData)&t2) != 0)
+				TiGetTypeExact(tile) | dinfo, &newArea, connectMask,
+				dbcFindTileFunc, (ClientData)&tad) != 0)
 		    {
-			STACKPUSH(INT2CD(t2), dbConnectStack);
+			STACKPUSH(PTR2CD(tad.tad_tile), dbConnectStack);
+			STACKPUSH(INT2CD(tad.tad_dinfo), dbConnectStack);
 			STACKPUSH(INT2CD(i), dbConnectStack);
 		    }
 		}
 		else if (DBSrPaintArea((Tile *) NULL, csa->csa_def->cd_planes[i],
 			&newArea, connectMask, dbcFindTileFunc,
-			(ClientData)&t2) != 0)
+			(ClientData)&tad) != 0)
 		{
-		    STACKPUSH(INT2CD(t2), dbConnectStack);
+		    STACKPUSH(PTR2CD(tad.tad_tile), dbConnectStack);
+		    STACKPUSH(INT2CD(tad.tad_dinfo), dbConnectStack);
 		    STACKPUSH(INT2CD(i), dbConnectStack);
 		}
 	    }
@@ -731,10 +670,13 @@ donesides:
  * ----------------------------------------------------------------------------
  */
 
+/** @typedef cb_database_srpaintnmarea_t */
+/** @typedef cb_database_srpaintarea_t */
 int
-dbcUnconnectFunc(tile, clientData)
+dbcUnconnectFunc(tile, dinfo, clientData)
     Tile *tile;				/* Current tile	*/
-    ClientData clientData;		/* Unused.	*/
+    TileType dinfo;			/* Split tile information, unused */
+    ClientData clientData;		/* Unused. */
 
 {
     return 1;
@@ -826,7 +768,8 @@ dbcConnectLabelFunc(scx, lab, tpath, csa2)
 	CellDef *orig_def = scx->scx_use->cu_def;
 	Label *slab;
 	int lidx = lab->lab_port;
-	TileTypeBitMask *connectMask;
+	bool foundOne;
+	const TileTypeBitMask *connectMask;
 
 	/* Check for equivalent ports. For any found, call	*/
 	/* DBTreeSrTiles recursively on the type and area	*/
@@ -837,6 +780,7 @@ dbcConnectLabelFunc(scx, lab, tpath, csa2)
 	/* are more equivalent ports, they will be found when	*/
 	/* processing this label's area.			*/
 
+	foundOne = FALSE;
 	for (slab = orig_def->cd_labels; slab != NULL; slab = slab->lab_next)
 	    if ((slab->lab_flags & PORT_DIR_MASK) && (slab != lab))
 		if (slab->lab_port == lidx)
@@ -897,6 +841,20 @@ dbcConnectLabelFunc(scx, lab, tpath, csa2)
 		    csa2->csa2_list[csa2->csa2_top].connectMask = connectMask;
 		    csa2->csa2_list[csa2->csa2_top].dinfo = 0;
 
+#if 0
+		    /* This warning is useful but currently is generating
+		     * multiple messages per instance and so its more of
+		     * an annoyance than an aid.
+		     */
+
+		    if (foundOne == FALSE)
+			TxError("Warning:  Port %s at location (%d %d) connects"
+				" a net across multiple disconnected areas!\n",
+				lab->lab_text, lab->lab_rect.r_xbot,
+				lab->lab_rect.r_ybot);
+#endif
+		    foundOne = TRUE;
+
 		    /* See above:  Process only one equivalent port at a time */
 		    break;
 		}
@@ -931,8 +889,9 @@ dbcConnectLabelFunc(scx, lab, tpath, csa2)
  */
 
 int
-dbcConnectFunc(tile, cx)
+dbcConnectFunc(tile, dinfo, cx)
     Tile *tile;			/* Tile found. */
+    TileType dinfo;		/* Split tile information */
     TreeContext *cx;		/* Describes context of search.  The client
 				 * data is a pointer to a conSrArg2 record
 				 * containing various required information.
@@ -940,12 +899,13 @@ dbcConnectFunc(tile, cx)
 {
     struct conSrArg2 *csa2;
     Rect tileArea, newarea;
-    TileTypeBitMask *connectMask, notConnectMask;
+    const TileTypeBitMask *connectMask;
+    TileTypeBitMask notConnectMask;
     Rect *srArea;
     SearchContext *scx = cx->tc_scx;
     SearchContext scx2;
-    TileType loctype = TiGetTypeExact(tile);
-    TileType dinfo = 0;
+    TileType loctype = TiGetTypeExact(tile) | dinfo;
+    TileType newdinfo = 0;
     int retval, i, pNum = cx->tc_plane;
     CellDef *def;
 
@@ -977,8 +937,8 @@ dbcConnectFunc(tile, cx)
 
     if (IsSplit(tile))
     {
-	dinfo = DBTransformDiagonal(loctype, &scx->scx_trans);
-	loctype = (SplitSide(tile)) ? SplitRightType(tile) : SplitLeftType(tile);
+	newdinfo = DBTransformDiagonal(loctype, &scx->scx_trans);
+	loctype = ((dinfo & TT_SIDE)) ? SplitRightType(tile) : SplitLeftType(tile);
     }
 
     /* See if the destination cell contains stuff over the whole
@@ -1016,7 +976,7 @@ dbcConnectFunc(tile, cx)
     def = csa2->csa2_use->cu_def;
     retval = 1;
     if (DBSrPaintNMArea((Tile *) NULL, def->cd_planes[pNum],
-		dinfo, &newarea, &notConnectMask, dbcUnconnectFunc,
+		newdinfo, &newarea, &notConnectMask, dbcUnconnectFunc,
 		(ClientData) NULL) == 0)
 	retval = 0;
 
@@ -1025,7 +985,7 @@ dbcConnectFunc(tile, cx)
      * the storage for the current list element.
      */
 
-    DBNMPaintPlane(def->cd_planes[pNum], dinfo,
+    DBNMPaintPlane(def->cd_planes[pNum], newdinfo,
 		&newarea, DBStdPaintTbl(loctype, pNum),
 		(PaintUndoInfo *) NULL);
 
@@ -1042,14 +1002,14 @@ dbcConnectFunc(tile, cx)
 
     /* Only extend those sides bordering the diagonal tile */
 
-    if (dinfo & TT_DIAGONAL)
+    if (newdinfo & TT_DIAGONAL)
     {
-	if (dinfo & TT_SIDE)			/* right */
+	if (newdinfo & TT_SIDE)			/* right */
 	    newarea.r_xtop += 1;
 	else					/* left */
 	    newarea.r_xbot -= 1;
-	if (((dinfo & TT_SIDE) >> 1)
-		== (dinfo & TT_DIRECTION))	/* top */
+	if (((newdinfo & TT_SIDE) >> 1)
+		== (newdinfo & TT_DIRECTION))	/* top */
 	    newarea.r_ytop += 1;
 	else					/* bottom */
 	    newarea.r_ybot -= 1;
@@ -1077,7 +1037,13 @@ dbcConnectFunc(tile, cx)
     if (++csa2->csa2_top == CSA2_LIST_SIZE)
     {
 	/* Reached list size limit---need to push the list and	*/
-	/* start a new one.					*/
+	/* start a new one.  NOTE:  Setting lasttop to -1 means	*/
+	/* that some entries may be duplicated between the	*/
+	/* stacks, which is a small inefficiency.  In theory,	*/
+	/* lasttop could be left as is, then if lasttop > top	*/
+	/* when searching the last 5 entries, pop the stack, do	*/
+	/* the search, and then push the stack again.  But it's	*/
+	/* a lot easier just to be slightly inefficient.	*/
 
 	conSrArea *newlist;
 
@@ -1085,11 +1051,12 @@ dbcConnectFunc(tile, cx)
 	StackPush((ClientData)csa2->csa2_list, csa2->csa2_stack);
 	csa2->csa2_list = newlist;
 	csa2->csa2_top = 0;
+	csa2->csa2_lasttop = -1;
     }
 
     csa2->csa2_list[csa2->csa2_top].area = newarea;
     csa2->csa2_list[csa2->csa2_top].connectMask = connectMask;
-    csa2->csa2_list[csa2->csa2_top].dinfo = dinfo;
+    csa2->csa2_list[csa2->csa2_top].dinfo = newdinfo;
 
     return 0;
 }
@@ -1155,7 +1122,7 @@ DBTreeCopyConnect(scx, mask, xMask, connect, area, doLabels, destUse)
 					 */
 {
     struct conSrArg2 csa2;
-    TileTypeBitMask *newmask;
+    const TileTypeBitMask *newmask;
     TileType newtype;
     unsigned char searchtype;
 
@@ -1244,7 +1211,8 @@ DBTreeCopyConnect(scx, mask, xMask, connect, area, doLabels, destUse)
 	    if (DBTreeSrLabels(scx, newmask, xMask, &tpath, searchtype,
 			dbcConnectLabelFunc, (ClientData) &csa2) != 0)
 	    {
-		TxError("Connection search hit memory limit and stopped.\n");
+		TxError("Connection search was interrupted or hit "
+			"memory limit and stopped.\n");
 		break;
 	    }
     }

database/DBexpand.c

@@ -39,6 +39,7 @@ struct expandArg
 {
     bool	ea_deref;	/* TRUE if root def dereference flag is set */
     int		ea_xmask;	/* Expand mask. */
+    int		ea_type;	/* Expand, unexpand, or toggle */
     int		(*ea_func)();	/* Function to call for each cell whose
 				 * status is changed.
 				 */
@@ -67,15 +68,22 @@ struct expandArg
  */
 
 void
-DBExpand(cellUse, expandMask, expandFlag)
+DBExpand(cellUse, expandMask, expandType)
     CellUse *cellUse;
     int expandMask;
-    bool expandFlag;
+    int expandType;
 {
     CellDef *def;
+    bool expandFlag, expandTest;
  
-    if (DBDescendSubcell(cellUse, expandMask) == expandFlag)
-	return;
+    expandTest = DBDescendSubcell(cellUse, expandMask);
+    if ((expandType & DB_EXPAND_MASK) == DB_EXPAND_TOGGLE)
+	expandFlag = expandTest;
+    else
+    {
+	expandFlag = ((expandType & DB_EXPAND_MASK) == DB_EXPAND) ? TRUE : FALSE;
+	if (expandFlag == expandTest) return;
+    }
 
     if (expandFlag)
     {
@@ -130,17 +138,17 @@ DBExpand(cellUse, expandMask, expandFlag)
  */
 
 void
-DBExpandAll(rootUse, rootRect, expandMask, expandFlag, func, cdarg)
+DBExpandAll(rootUse, rootRect, expandMask, expandType, func, cdarg)
     CellUse *rootUse;	/* Root cell use from which search begins */
     Rect *rootRect;	/* Area to be expanded, in root coordinates */
     int expandMask;	/* Window mask in which cell is to be expanded */
-    bool expandFlag;	/* TRUE => expand, FALSE => unexpand */
+    int expandType;	/* DB_EXPAND, DB_UNEXPAND, DB_EXPAND_TOGGLE */
     int (*func)();	/* Function to call for each cell whose expansion
 			 * status is modified.  NULL means don't call anyone.
 			 */
     ClientData cdarg;	/* Argument to pass to func. */
 {
-    int dbExpandFunc(), dbUnexpandFunc();
+    int dbExpandFunc();
     SearchContext scontext;
     struct expandArg arg;
 
@@ -148,29 +156,26 @@ DBExpandAll(rootUse, rootRect, expandMask, expandFlag, func, cdarg)
 	(void) DBCellRead(rootUse->cu_def, TRUE, TRUE, NULL);
 
     /*
-     * Walk through the area and set the expansion state
-     * appropriately.
+     * Walk through the area and set the expansion state appropriately.
      */
 
     arg.ea_xmask = expandMask;
     arg.ea_func = func;
     arg.ea_arg = cdarg;
+    arg.ea_type = expandType;
     arg.ea_deref = (rootUse->cu_def->cd_flags & CDDEREFERENCE) ? TRUE : FALSE;
 
     scontext.scx_use = rootUse;
     scontext.scx_trans = GeoIdentityTransform;
     scontext.scx_area = *rootRect;
-    if (expandFlag)
-	DBCellSrArea(&scontext, dbExpandFunc, (ClientData) &arg);
-    else
-	DBCellSrArea(&scontext, dbUnexpandFunc, (ClientData) &arg);
+    DBCellSrArea(&scontext, dbExpandFunc, (ClientData) &arg);
 }
 
 /*
  * dbExpandFunc --
  *
  * Filter function called by DBCellSrArea on behalf of DBExpandAll above
- * when cells are being expanded.
+ * when cells are being expanded, unexpanded, or toggled.
  */
 
 int
@@ -184,68 +189,55 @@ dbExpandFunc(scx, arg)
 {
     CellUse *childUse = scx->scx_use;
     int n = DBLambda[1];
+    int expandTest;
+    int expandType = (arg->ea_type & DB_EXPAND_MASK);
+    int expandSurround = (arg->ea_type & DB_EXPAND_SURROUND_MASK);
+    bool surround;
+
+    expandTest = DBDescendSubcell(childUse, arg->ea_xmask);
 
     /*
      * Change the expansion status of this cell if necessary.  Call the
      * client's function if the expansion status has changed.
      */
 
-    if (!DBDescendSubcell(childUse, arg->ea_xmask))
+    if (!expandTest && ((expandType == DB_EXPAND) || (expandType == DB_EXPAND_TOGGLE)))
     {
-	/* If the cell is unavailable, then don't expand it.
-	 */
-	if ((childUse->cu_def->cd_flags & CDAVAILABLE) == 0)
+	surround = (!GEO_SURROUND(&childUse->cu_def->cd_bbox, &scx->scx_area)
+			|| GEO_SURROUND(&scx->scx_area, &childUse->cu_def->cd_bbox));
+	if (surround || (expandSurround == DB_EXPAND_OVERLAP))
 	{
-	    /* If the parent is dereferenced, then the child should be, too */
-	    if (arg->ea_deref) childUse->cu_def->cd_flags |= CDDEREFERENCE;
-	    if(!DBCellRead(childUse->cu_def, TRUE, TRUE, NULL))
+	    /* If the cell is unavailable, then don't expand it.
+	     */
+	    if ((childUse->cu_def->cd_flags & CDAVAILABLE) == 0)
 	    {
-		TxError("Cell %s is unavailable.  It could not be expanded.\n",
-			childUse->cu_def->cd_name);
-		return 2;
+		/* If the parent is dereferenced, then the child should be, too */
+		if (arg->ea_deref) childUse->cu_def->cd_flags |= CDDEREFERENCE;
+		if (!DBCellRead(childUse->cu_def, TRUE, TRUE, NULL))
+		{
+		    TxError("Cell %s is unavailable.  It could not be expanded.\n",
+				childUse->cu_def->cd_name);
+		    return 2;
+		}
+	    }
+
+	    childUse->cu_expandMask |= arg->ea_xmask;
+	    expandTest = TRUE;
+	    if (arg->ea_func != NULL)
+	    {
+		if ((*arg->ea_func)(childUse, arg->ea_arg) != 0) return 1;
 	    }
 	}
-
-	childUse->cu_expandMask |= arg->ea_xmask;
-	if (arg->ea_func != NULL)
-	{
-	    if ((*arg->ea_func)(childUse, arg->ea_arg) != 0) return 1;
-	}
     }
-
-    if (DBCellSrArea(scx, dbExpandFunc, (ClientData) arg))
-	return 1;
-    return 2;
-}
-
-/*
- * dbUnexpandFunc --
- *
- * Filter function called by DBCellSrArea on behalf of DBExpandAll above
- * when cells are being unexpanded.
- */
-
-int
-dbUnexpandFunc(scx, arg)
-    SearchContext *scx;	/* Pointer to search context containing
-					 * child use, search area in coor-
-					 * dinates of the child use, and
-					 * transform back to "root".
-					 */
-    struct expandArg *arg;	/* Client data from caller */
-{
-    CellUse *childUse = scx->scx_use;
-
-    /*
-     * Change the expansion status of this cell if necessary.
-     */
-
-    if (DBDescendSubcell(childUse, arg->ea_xmask))
+    else if (expandTest && ((expandType == DB_UNEXPAND) ||
+			(expandType == DB_EXPAND_TOGGLE)))
     {
-	if (!GEO_SURROUND(&childUse->cu_def->cd_bbox, &scx->scx_area)
-	    || GEO_SURROUND(&scx->scx_area, &childUse->cu_def->cd_bbox))
+	surround = (!GEO_SURROUND(&childUse->cu_def->cd_bbox, &scx->scx_area)
+			|| GEO_SURROUND(&scx->scx_area, &childUse->cu_def->cd_bbox));
+	if (surround || (expandSurround == DB_EXPAND_OVERLAP))
 	{
 	    childUse->cu_expandMask &= ~arg->ea_xmask;
+	    expandTest = FALSE;
 
 	    /* Call the client's function, if there is one. */
 
@@ -256,11 +248,7 @@ dbUnexpandFunc(scx, arg)
 	}
     }
 
-    /* Don't recursively search things that aren't already expanded. */
-
-    else return 2;
-
-    if (DBCellSrArea(scx, dbUnexpandFunc, (ClientData) arg))
+    if (DBCellSrArea(scx, dbExpandFunc, (ClientData) arg))
 	return 1;
     return 2;
 }

database/DBlabel.c

@@ -280,6 +280,7 @@ DBEraseGlobLabel(cellDef, area, mask, areaReturn, globmatch)
     bool erasedAny = FALSE;
     TileType newType;
 
+    free_magic1_t mm1 = freeMagic1_init();
     labPrev = NULL;
     lab = cellDef->cd_labels;
     while (lab != NULL)
@@ -313,7 +314,7 @@ DBEraseGlobLabel(cellDef, area, mask, areaReturn, globmatch)
 	if ((lab->lab_font >= 0) && areaReturn)
 	    GeoInclude(&lab->lab_bbox, areaReturn);
 
-	freeMagic((char *) lab);
+	freeMagic1(&mm1, (char *) lab);
 	lab = lab->lab_next;
 	erasedAny = TRUE;
 	continue;
@@ -321,6 +322,7 @@ DBEraseGlobLabel(cellDef, area, mask, areaReturn, globmatch)
 	nextLab: labPrev = lab;
 	lab = lab->lab_next;
     }
+    freeMagic1_end(&mm1);
 
     if (erasedAny)
 	cellDef->cd_flags |= CDMODIFIED|CDGETNEWSTAMP;
@@ -442,6 +444,7 @@ DBEraseLabelsByContent(def, rect, type, text)
 {
     Label *lab, *labPrev;
 
+    free_magic1_t mm1 = freeMagic1_init();
     for (labPrev = NULL, lab = def->cd_labels;
 	    lab != NULL;
 	    labPrev = lab, lab = lab->lab_next)
@@ -457,7 +460,7 @@ DBEraseLabelsByContent(def, rect, type, text)
 	else labPrev->lab_next = lab->lab_next;
 	if (def->cd_lastLabel == lab)
 	    def->cd_lastLabel = labPrev;
-	freeMagic((char *) lab);
+	freeMagic1(&mm1, (char *) lab);
 
 	/* Don't iterate through loop, since this will skip a label:
 	 * just go back to top.  This is tricky!
@@ -467,6 +470,7 @@ DBEraseLabelsByContent(def, rect, type, text)
 	if (lab == NULL) break;
 	else goto nextCheck;
     }
+    freeMagic1_end(&mm1);
 }
 
 /*
@@ -495,6 +499,7 @@ DBRemoveLabel(def, refLab)
 {
     Label *lab, *labPrev;
 
+    free_magic1_t mm1 = freeMagic1_init();
     for (labPrev = NULL, lab = def->cd_labels;
 	    lab != NULL;
 	    labPrev = lab, lab = lab->lab_next)
@@ -508,7 +513,7 @@ DBRemoveLabel(def, refLab)
 	else labPrev->lab_next = lab->lab_next;
 	if (def->cd_lastLabel == lab)
 	    def->cd_lastLabel = labPrev;
-	freeMagic((char *) lab);
+	freeMagic1(&mm1, (char *) lab);
 
 	/* Don't iterate through loop, since this will skip a label:
 	 * just go back to top.  This is tricky!
@@ -518,6 +523,7 @@ DBRemoveLabel(def, refLab)
 	if (lab == NULL) break;
 	else goto nextCheck;
     }
+    freeMagic1_end(&mm1);
 }
 
 /*
@@ -568,7 +574,8 @@ DBReOrientLabel(cellDef, area, newPos)
  * dbGetLabelArea ---
  *
  * Callback function used by DBAdjustLabels.  Find all material under a label
- * that is *not* the label type, and return the 
+ * that is *not* the label type, and return the label area adjusted to leave
+ * out that amount.
  *
  * Note:  This clips in a regular order, and does not consider what is the
  * largest rectangular area outside the area that has been clipped out.
@@ -577,8 +584,9 @@ DBReOrientLabel(cellDef, area, newPos)
  */
 
 int
-dbGetLabelArea(tile, area)
+dbGetLabelArea(tile, dinfo, area)
     Tile *tile;		/* Tile found. */
+    TileType dinfo;	/* Split tile information (unused) */
     Rect *area;		/* Area to be modified. */
 {
     Rect r;
@@ -597,6 +605,26 @@ dbGetLabelArea(tile, area)
     return 0;
 }
 
+/*
+ * ----------------------------------------------------------------------------
+ *
+ * dbLabelNotEmpty ---
+ *
+ * Callback function used by DBAdjustLabels.  Finds any material under a
+ * label that is the label type, and returns 1 to stop the search.
+ *
+ * ----------------------------------------------------------------------------
+ */
+
+int
+dbLabelNotEmpty(tile, dinfo, clientData)
+    Tile *tile;		/* Tile found. */
+    TileType dinfo;	/* Split tile information (unused) */
+    ClientData clientData;	/* (unused) */
+{
+    return 1;
+}
+
 /*
  * ----------------------------------------------------------------------------
  *
@@ -654,28 +682,37 @@ DBAdjustLabels(def, area)
 
 	    TTMaskSetOnlyType(&lmask, lab->lab_type);
 	    /* To do:  Add compatible types (contact, residue) */
-	    TTMaskCom(&lmask);
 
-	    r = lab->lab_rect;
-	    DBSrPaintArea((Tile *) NULL, def->cd_planes[DBPlane(lab->lab_type)],
-		    &lab->lab_rect, &lmask, dbGetLabelArea, (ClientData) &r);
-
-	    if (!GEO_RECTNULL(&r))
+	    /* If there is no material left inside the label area, then
+	     * the label gets reassigned to space.
+	     */
+	    if (DBSrPaintArea((Tile *) NULL, def->cd_planes[DBPlane(lab->lab_type)],
+		    &lab->lab_rect, &lmask, dbLabelNotEmpty, (ClientData)NULL) == 1)
 	    {
-		if ((DBVerbose >= DB_VERBOSE_ALL) && ((def->cd_flags & CDINTERNAL) == 0))
-		{
-		    TxPrintf("Adjusting size of label \"%s\" in cell %s.\n",
-				lab->lab_text, def->cd_name);
-		}
+		TTMaskCom(&lmask);
 
-		DBUndoEraseLabel(def, lab);
-		DBWLabelChanged(def, lab, DBW_ALLWINDOWS);
-		lab->lab_rect = r;
-		DBFontLabelSetBBox(lab);
-		DBUndoPutLabel(def, lab);
-		DBWLabelChanged(def, lab, DBW_ALLWINDOWS);
-		modified = TRUE;
-		adjusted = TRUE;
+		r = lab->lab_rect;
+		DBSrPaintArea((Tile *) NULL, def->cd_planes[DBPlane(lab->lab_type)],
+		    	&lab->lab_rect, &lmask, dbGetLabelArea, (ClientData) &r);
+
+		if (!GEO_RECTNULL(&r))
+		{
+		    if ((DBVerbose >= DB_VERBOSE_ALL) &&
+				((def->cd_flags & CDINTERNAL) == 0))
+		    {
+			TxPrintf("Adjusting size of label \"%s\" in cell %s.\n",
+				lab->lab_text, def->cd_name);
+		    }
+
+		    DBUndoEraseLabel(def, lab);
+		    DBWLabelChanged(def, lab, DBW_ALLWINDOWS);
+		    lab->lab_rect = r;
+		    DBFontLabelSetBBox(lab);
+		    DBUndoPutLabel(def, lab);
+		    DBWLabelChanged(def, lab, DBW_ALLWINDOWS);
+		    modified = TRUE;
+		    adjusted = TRUE;
+		}
 	    }
 	}
 
@@ -760,8 +797,10 @@ DBAdjustLabelsNew(def, area)
 		    def->cd_lastLabel = labPrev;
 		DBUndoEraseLabel(def, lab);
 		DBWLabelChanged(def, lab, DBW_ALLWINDOWS);
-		freeMagic((char *) lab);
+		free_magic1_t mm1 = freeMagic1_init();
+		freeMagic1(&mm1, (char *) lab);
 		lab = lab->lab_next;
+		freeMagic1_end(&mm1);
 		modified = TRUE;
 		continue;
 	    }
@@ -1077,14 +1116,15 @@ DBPickLabelLayer(def, lab, doCalma)
  */
 
 int
-dbPickFunc1(tile, mask)
+dbPickFunc1(tile, dinfo, mask)
     Tile *tile;			/* Tile found. */
+    TileType dinfo;		/* Split tile information */
     TileTypeBitMask *mask;	/* Mask to be modified. */
 {
     TileType type;
 
     if (IsSplit(tile))
-	type = (SplitSide(tile)) ? SplitRightType(tile) : SplitLeftType(tile);
+	type = (dinfo & TT_SIDE) ? SplitRightType(tile) : SplitLeftType(tile);
     else
 	type = TiGetType(tile);
 
@@ -1103,15 +1143,16 @@ dbPickFunc1(tile, mask)
  */
 
 int
-dbPickFunc2(tile, mask)
+dbPickFunc2(tile, dinfo, mask)
     Tile *tile;			/* Tile found. */
+    TileType dinfo;		/* Split tile information */
     TileTypeBitMask *mask;	/* Mask to be modified. */
 {
     TileType type;
     TileTypeBitMask tmp, *rMask;
 
     if (IsSplit(tile))
-	type = (SplitSide(tile)) ? SplitRightType(tile) : SplitLeftType(tile);
+	type = (dinfo & TT_SIDE) ? SplitRightType(tile) : SplitLeftType(tile);
     else
 	type = TiGetType(tile);
 
@@ -1744,8 +1785,10 @@ DBLoadFont(fontfile, scale)
 		}
 
 		/* Remove the pointlist */
+		free_magic1_t mm1 = freeMagic1_init();
 		for (newPath = pathStart; newPath != NULL; newPath = newPath->fp_next)
-		    freeMagic(newPath);
+		    freeMagic1(&mm1, newPath);
+		freeMagic1_end(&mm1);
 		pathStart = NULL;
 	    }
 	    else

database/DBpaint.c

@@ -59,6 +59,8 @@ Tile *TiNMMergeRight();
 Tile *TiNMMergeLeft();
 
 #ifdef	PAINTDEBUG
+void dbPaintShowTile(Tile *tile, PaintUndoInfo *undo, char *str);
+
 int dbPaintDebug = 0;
 #endif	/* PAINTDEBUG */
 
@@ -271,9 +273,10 @@ DBPaintPlane0(plane, area, resultTbl, undo, method)
      * search.
      */
 
+    Tile *delayed = NULL; /* delayed free to extend lifetime */
     start.p_x = area->r_xbot;
     start.p_y = area->r_ytop - 1;
-    tile = plane->pl_hint;
+    tile = PlaneGetHint(plane);
     GOTOPOINT(tile, &start);
 
     /* Each iteration visits another tile on the LHS of the search area */
@@ -310,6 +313,11 @@ enumerate:
 	 * Set up the directions in which we will have to
 	 * merge initially.  Clipping can cause some of these
 	 * to be turned off.
+	 *
+	 * The search runs from left to right, top to bottom.
+	 * Therefore always merge left and up, but never right
+	 * and down, unless at or beyond the each of the search
+	 * area.
 	 */
 	mergeFlags = MRG_TOP | MRG_LEFT;
 	if (RIGHT(tile) >= area->r_xtop) mergeFlags |= MRG_RIGHT;
@@ -339,6 +347,7 @@ enumerate:
 	     * Merging is only necessary if we clip to the left or to
 	     * the right, and then only to the top or the bottom.
 	     * We do the merge in-line for efficiency.
+	     * Clipping of split tiles is more complicated.
 	     */
 
 	    /* Clip up */
@@ -353,13 +362,17 @@ enumerate:
 			newType = (method == (unsigned char)PAINT_XOR) ?
 				 *resultTbl : resultTbl[oldType];
 
-			tile = TiNMMergeLeft(tile, plane);
-			TiNMMergeRight(TR(newtile), plane);
+			if (mergeFlags & MRG_LEFT)
+			    tile = TiNMMergeLeft(tile, plane);
+			if ((mergeFlags & MRG_RIGHT) || SplitDirection(newtile) == 1)
+			    TiNMMergeRight(TR(newtile), plane);
 		    }
 		    else
 		    {
-			TiNMMergeLeft(newtile, plane);
-			TiNMMergeRight(TR(tile), plane);
+			if (mergeFlags & MRG_LEFT)
+			    TiNMMergeLeft(newtile, plane);
+			if ((mergeFlags & MRG_RIGHT) || SplitDirection(tile) == 1)
+			    TiNMMergeRight(TR(tile), plane);
 		    }
 		}
 		else
@@ -388,13 +401,17 @@ enumerate:
 			newType = (method == (unsigned char)PAINT_XOR) ?
 				 *resultTbl : resultTbl[oldType];
 
-			tile = TiNMMergeLeft(tile, plane);
-			TiNMMergeRight(TR(newtile), plane);
+			if (mergeFlags & MRG_LEFT)
+			    tile = TiNMMergeLeft(tile, plane);
+			if ((mergeFlags & MRG_RIGHT) || SplitDirection(newtile) == 0)
+			    TiNMMergeRight(TR(newtile), plane);
 		    }
 		    else
 		    {
-			TiNMMergeLeft(newtile, plane);
-			TiNMMergeRight(TR(tile), plane);
+			if (mergeFlags & MRG_LEFT)
+			    TiNMMergeLeft(newtile, plane);
+			if ((mergeFlags & MRG_RIGHT) || SplitDirection(tile) == 0)
+			    TiNMMergeRight(TR(tile), plane);
 		    }
 		}
 		else
@@ -423,13 +440,17 @@ enumerate:
 			newType = (method == (unsigned char)PAINT_XOR) ?
 				 *resultTbl : resultTbl[oldType];
 
-			tile = TiNMMergeLeft(tile, plane);
-			TiNMMergeRight(LB(newtile), plane);
+			if (mergeFlags & MRG_LEFT)
+			    tile = TiNMMergeLeft(tile, plane);
+			if (mergeFlags & MRG_RIGHT)
+			    TiNMMergeRight(LB(newtile), plane);
 		    }
 		    else
 		    {
-			TiNMMergeRight(newtile, plane);
-			TiNMMergeLeft(LB(tile), plane);
+			if (mergeFlags & MRG_LEFT)
+			    TiNMMergeRight(newtile, plane);
+			if (mergeFlags & MRG_RIGHT)
+			    TiNMMergeLeft(LB(tile), plane);
 		    }
 		}
 		else
@@ -439,11 +460,11 @@ enumerate:
 
 		    /* Merge the outside tile to its top */
 		    tp = RT(newtile);
-		    if (CANMERGE_Y(newtile, tp)) TiJoinY(newtile, tp, plane);
+		    if (CANMERGE_Y(newtile, tp)) TiJoinY1(&delayed, newtile, tp, plane);
 
 		    /* Merge the outside tile to its bottom */
 		    tp = LB(newtile);
-		    if (CANMERGE_Y(newtile, tp)) TiJoinY(newtile, tp, plane);
+		    if (CANMERGE_Y(newtile, tp)) TiJoinY1(&delayed, newtile, tp, plane);
 		}
 		mergeFlags &= ~MRG_RIGHT;
 	    }
@@ -466,13 +487,13 @@ enumerate:
 			newType = (method == (unsigned char)PAINT_XOR) ?
 				 *resultTbl : resultTbl[oldType];
 
-			// tile = TiNMMergeRight(tile, plane);
-			TiNMMergeLeft(LB(newtile), plane);
+			if (mergeFlags & MRG_LEFT)
+			    TiNMMergeLeft(LB(newtile), plane);
 		    }
 		    else
 		    {
-			TiNMMergeLeft(newtile, plane);
-			// TiNMMergeRight(LB(tile), plane);
+			if (mergeFlags & MRG_LEFT)
+			    TiNMMergeLeft(newtile, plane);
 		    }
 		}
 		else
@@ -483,11 +504,11 @@ enumerate:
 
 		    /* Merge the outside tile to its top */
 		    tp = RT(newtile);
-		    if (CANMERGE_Y(newtile, tp)) TiJoinY(newtile, tp, plane);
+		    if (CANMERGE_Y(newtile, tp)) TiJoinY1(&delayed, newtile, tp, plane);
 
 		    /* Merge the outside tile to its bottom */
 		    tp = LB(newtile);
-		    if (CANMERGE_Y(newtile, tp)) TiJoinY(newtile, tp, plane);
+		    if (CANMERGE_Y(newtile, tp)) TiJoinY1(&delayed, newtile, tp, plane);
 		}
 		mergeFlags &= ~MRG_LEFT;
 	    }
@@ -579,7 +600,7 @@ clipdone:
 	if (mergeFlags & MRG_TOP)
 	{
 	    tp = RT(tile);
-	    if (CANMERGE_Y(tile, tp)) TiJoinY(tile, tp, plane);
+	    if (CANMERGE_Y(tile, tp)) TiJoinY1(&delayed, tile, tp, plane);
 #ifdef	PAINTDEBUG
 	    if (dbPaintDebug)
 		dbPaintShowTile(tile, undo, "merged up (CHEAP)");
@@ -588,7 +609,7 @@ clipdone:
 	if (mergeFlags & MRG_BOTTOM)
 	{
 	    tp = LB(tile);
-	    if (CANMERGE_Y(tile, tp)) TiJoinY(tile, tp, plane);
+	    if (CANMERGE_Y(tile, tp)) TiJoinY1(&delayed, tile, tp, plane);
 #ifdef	PAINTDEBUG
 	    if (dbPaintDebug)
 		dbPaintShowTile(tile, undo, "merged down (CHEAP)");
@@ -648,7 +669,7 @@ done:
 	start.p_x = area->r_xbot;
 	start.p_y = area->r_ytop - 1;
 
-	tile = plane->pl_hint;
+	tile = PlaneGetHint(plane);
 	GOTOPOINT(tile, &start);
 
 	while (TOP(tile) > area->r_ybot)
@@ -696,7 +717,8 @@ enum2:
     }
 
 done2:
-    plane->pl_hint = tile;
+    PlaneSetHint(plane, tile);
+    TiFreeIf(delayed);
     return 0;
 }
 
@@ -719,7 +741,7 @@ DBSplitTile(plane, point, splitx)
     int splitx;
 {
     Tile *tile, *newtile, *tp;
-    tile = plane->pl_hint;
+    tile = PlaneGetHint(plane);
     GOTOPOINT(tile, point);
 
     if (IsSplit(tile))		/* This should always be true */
@@ -793,7 +815,7 @@ DBFracturePlane(plane, area, resultTbl, undo)
 
     start.p_x = area->r_xbot;
     start.p_y = area->r_ytop - 1;
-    tile = plane->pl_hint;
+    tile = PlaneGetHint(plane);
     GOTOPOINT(tile, &start);
 
     /* Each iteration visits another tile on the LHS of the search area */
@@ -990,7 +1012,7 @@ paintdone:
     }
 
 done:
-    plane->pl_hint = tile;
+    PlaneSetHint(plane, tile);
 }
 
 /*
@@ -1032,11 +1054,12 @@ DBMergeNMTiles0(plane, area, undo, mergeOnce)
     int clipTop;
     Tile *tile, *tp, *tp2, *newtile, *tpnew;
     int aspecta, aspectb;
+    Tile *delayed = NULL; /* delayed free to extend lifetime */
     TileType ttype, ltype, rtype;
 
     start.p_x = area->r_xbot;
     start.p_y = area->r_ytop - 1;
-    tile = plane->pl_hint;
+    tile = PlaneGetHint(plane);
     GOTOPOINT(tile, &start);
 
     /* Each iteration visits another tile on the LHS of the search area */
@@ -1121,23 +1144,23 @@ nmenum:
 			newtile = TiSplitY(tp2, TOP(tile));
 			TiSetBody(newtile, ltype);
 			if (CANMERGE_X(newtile, BL(newtile)))
-			    TiJoinX(newtile, BL(newtile), plane);
+			    TiJoinX1(&delayed, newtile, BL(newtile), plane);
 			if (CANMERGE_X(newtile, TR(newtile)))
-			    TiJoinX(newtile, TR(newtile), plane);
+			    TiJoinX1(&delayed, newtile, TR(newtile), plane);
 			if (CANMERGE_Y(newtile, RT(newtile)))
-			    TiJoinY(newtile, RT(newtile), plane);
+			    TiJoinY1(&delayed, newtile, RT(newtile), plane);
 		    }
 		    if (LEFT(tp2) < LEFT(tp))
 		    {
 			newtile = TiSplitX(tp2, LEFT(tp));
 			TiSetBody(newtile, ltype);
 			if (CANMERGE_Y(tp2, LB(tp2)))
-			    TiJoinY(tp2, LB(tp2), plane);
+			    TiJoinY1(&delayed, tp2, LB(tp2), plane);
 			if (CANMERGE_Y(tp2, RT(tp2)))
-			    TiJoinY(tp2, RT(tp2), plane);
+			    TiJoinY1(&delayed, tp2, RT(tp2), plane);
 			tp2 = newtile;
 		    }
-		    TiJoinY(tp2, tp, plane);
+		    TiJoinY1(&delayed, tp2, tp, plane);
 		    tp = tp2;
 		    tp2 = RT(tp2);
 		}
@@ -1151,11 +1174,11 @@ nmenum:
 			newtile = TiSplitY(tp2, BOTTOM(tp));
 			TiSetBody(newtile, rtype);
 			if (CANMERGE_X(tp2, BL(tp2)))
-			    TiJoinX(tp2, BL(tp2), plane);
+			    TiJoinX1(&delayed, tp2, BL(tp2), plane);
 			if (CANMERGE_X(tp2, TR(tp2)))
-			    TiJoinX(tp2, TR(tp2), plane);
+			    TiJoinX1(&delayed, tp2, TR(tp2), plane);
 			if (CANMERGE_Y(tp2, LB(tp2)))
-			    TiJoinY(tp2, LB(tp2), plane);
+			    TiJoinY1(&delayed, tp2, LB(tp2), plane);
 			tp2 = newtile;
 		    }
 		    if (RIGHT(tp2) > RIGHT(tile))
@@ -1163,16 +1186,16 @@ nmenum:
 			newtile = TiSplitX(tp2, RIGHT(tile));
 			TiSetBody(newtile, rtype);
 			if (CANMERGE_Y(newtile, LB(newtile)))
-			    TiJoinY(newtile, LB(newtile), plane);
+			    TiJoinY1(&delayed, newtile, LB(newtile), plane);
 			if (CANMERGE_Y(newtile, RT(newtile)))
-			    TiJoinY(newtile, RT(newtile), plane);
+			    TiJoinY1(&delayed, newtile, RT(newtile), plane);
 		    }
-		    TiJoinY(tp2, tile, plane);
+		    TiJoinY1(&delayed, tp2, tile, plane);
 		    tile = tp2;
 		    tp2 = LB(tp2);
 		}
 		/* Merge tp and tile */
-		TiJoinX(tile, tp, plane);
+		TiJoinX1(&delayed, tile, tp, plane);
 		TiSetBody(tile, ttype);
 	    }
 	    else	/* split direction 1 */
@@ -1213,11 +1236,11 @@ nmenum:
 			newtile = TiSplitY(tp2, BOTTOM(tp));
 			TiSetBody(newtile, ltype);
 			if (CANMERGE_X(tp2, BL(tp2)))
-			    TiJoinX(tp2, BL(tp2), plane);
+			    TiJoinX1(&delayed, tp2, BL(tp2), plane);
 			if (CANMERGE_X(tp2, TR(tp2)))
-			    TiJoinX(tp2, TR(tp2), plane);
+			    TiJoinX1(&delayed, tp2, TR(tp2), plane);
 			if (CANMERGE_Y(tp2, LB(tp2)))
-			    TiJoinY(tp2, LB(tp2), plane);
+			    TiJoinY1(&delayed, tp2, LB(tp2), plane);
 			tp2 = newtile;
 		    }
 		    if (LEFT(tp2) < LEFT(tile))
@@ -1225,12 +1248,12 @@ nmenum:
 			newtile = TiSplitX(tp2, LEFT(tile));
 			TiSetBody(newtile, ltype);
 			if (CANMERGE_Y(tp2, LB(tp2)))
-			    TiJoinY(tp2, LB(tp2), plane);
+			    TiJoinY1(&delayed, tp2, LB(tp2), plane);
 			if (CANMERGE_Y(tp2, RT(tp2)))
-			    TiJoinY(tp2, RT(tp2), plane);
+			    TiJoinY1(&delayed, tp2, RT(tp2), plane);
 			tp2 = newtile;
 		    }
-		    TiJoinY(tp2, tile, plane);
+		    TiJoinY1(&delayed, tp2, tile, plane);
 		    tile = tp2;
 		    tp2 = LB(tp2);
 		}
@@ -1245,27 +1268,27 @@ nmenum:
 			newtile = TiSplitY(tp2, TOP(tile));
 			TiSetBody(newtile, rtype);
 			if (CANMERGE_X(newtile, BL(newtile)))
-			    TiJoinX(newtile, BL(newtile), plane);
+			    TiJoinX1(&delayed, newtile, BL(newtile), plane);
 			if (CANMERGE_X(newtile, TR(newtile)))
-			    TiJoinX(newtile, TR(newtile), plane);
+			    TiJoinX1(&delayed, newtile, TR(newtile), plane);
 			if (CANMERGE_Y(newtile, RT(newtile)))
-			    TiJoinY(newtile, RT(newtile), plane);
+			    TiJoinY1(&delayed, newtile, RT(newtile), plane);
 		    }
 		    if (RIGHT(tp2) > RIGHT(tp))
 		    {
 			newtile = TiSplitX(tp2, RIGHT(tp));
 			TiSetBody(newtile, rtype);
 			if (CANMERGE_Y(newtile, LB(newtile)))
-			    TiJoinY(newtile, LB(newtile), plane);
+			    TiJoinY1(&delayed, newtile, LB(newtile), plane);
 			if (CANMERGE_Y(newtile, RT(newtile)))
-			    TiJoinY(newtile, RT(newtile), plane);
+			    TiJoinY1(&delayed, newtile, RT(newtile), plane);
 		    }
-		    TiJoinY(tp2, tp, plane);
+		    TiJoinY1(&delayed, tp2, tp, plane);
 		    tp = tp2;
 		    tp2 = RT(tp2);
 		}
 	 	/* Merge tp and tile */
-		TiJoinX(tile, tp, plane);
+		TiJoinX1(&delayed, tile, tp, plane);
 		TiSetBody(tile, ttype);
 	    }
 	    /* Now repeat until no more merging is possible */
@@ -1306,7 +1329,8 @@ nmenum:
     }
 
 nmdone:
-    plane->pl_hint = tile;
+    PlaneSetHint(plane, tile);
+    TiFreeIf(delayed);
     return 0;
 }
 
@@ -1411,10 +1435,6 @@ DBDiagonalProc(oldtype, dinfo)
     else
 	return -1;
 
-    /* For purposes of "undo" recording, record which side we just painted */
-    if (dinfo->side)
-	newtype |= TT_SIDE;
-
     return newtype;
 }
 
@@ -1499,7 +1519,7 @@ DBNMPaintPlane0(plane, exacttype, area, resultTbl, undo, method)
 	/* linked list out of them.				*/
 
 	lhead = NULL;
-	DBSrPaintArea(plane->pl_hint, plane, area, &DBAllTypeBits,
+	DBSrPaintArea(PlaneGetHint(plane), plane, area, &DBAllTypeBits,
 			dbNMEnumFunc, (ClientData) &lhead);
 
 	/*--------------------------------------------------------------*/
@@ -1519,7 +1539,7 @@ DBNMPaintPlane0(plane, exacttype, area, resultTbl, undo, method)
 	        GeoClip(&lhead->r_r, area);
 		start.p_x = area->r_xbot;
 		start.p_y = area->r_ytop - 1;
-		tile = plane->pl_hint;
+		tile = PlaneGetHint(plane);
 		GOTOPOINT(tile, &start);
 
 		/* Ignore tiles that don't interact.  This has	*/
@@ -1608,7 +1628,7 @@ DBNMPaintPlane0(plane, exacttype, area, resultTbl, undo, method)
 		    {
 			result = DBPaintPlane(plane, &(lr->r_r), DBSpecialPaintTbl,
 				(PaintUndoInfo *)NULL);
-			tile = plane->pl_hint;
+			tile = PlaneGetHint(plane);
 			GOTOPOINT(tile, &(lr->r_r.r_ll));
 			if (undo && UndoIsEnabled())
 			{
@@ -1768,12 +1788,14 @@ nextrect:
 	    lr = lr->r_next;
 	}
 
+	free_magic1_t mm1 = freeMagic1_init();
 	lr = lhead;
 	while (lr != NULL)
 	{
-	    freeMagic((char *) lr);
+	    freeMagic1(&mm1, (char *) lr);
 	    lr = lr->r_next;
 	}
+	freeMagic1_end(&mm1);
     }
     else
 	result = DBPaintPlane0(plane, area, resultTbl, undo, (method == PAINT_MARK) ?
@@ -1794,14 +1816,15 @@ nextrect:
  */
 
 int
-dbNMEnumFunc(tile, arg)
+dbNMEnumFunc(tile, dinfo, arg)
     Tile *tile;
+    TileType dinfo;
     LinkedRect **arg;
 {
     LinkedRect *lr;
 
     /* Ignore the second call to any diagonal---only count once! */
-    if (IsSplit(tile) && SplitSide(tile)) return 0;
+    if (IsSplit(tile) && (dinfo & TT_SIDE)) return 0;
 
     lr = (LinkedRect *) mallocMagic(sizeof(LinkedRect));
     TiToRect(tile, &lr->r_r);
@@ -1885,6 +1908,7 @@ dbPaintMerge(tile, newType, area, plane, mergeFlags, undo, mark)
     PaintUndoInfo *undo;	/* See DBPaintPlane() above */
     bool mark;			/* Mark tiles that were processed */
 {
+    Tile *delayed = NULL; /* delayed free to extend lifetime */
     Tile *tp, *tpLast;
     int ysplit;
 
@@ -1991,7 +2015,7 @@ dbPaintMerge(tile, newType, area, plane, mergeFlags, undo, mark)
 	    if (mark) dbMarkClient(tile, area);
 	}
 	if (BOTTOM(tp) < BOTTOM(tile)) tp = TiSplitY(tp, BOTTOM(tile));
-	TiJoinX(tile, tp, plane);
+	TiJoinX1(&delayed, tile, tp, plane);
 #ifdef	PAINTDEBUG
 	if (dbPaintDebug)
 	    dbPaintShowTile(tile, undo, "(DBMERGE) merged left");
@@ -2007,7 +2031,7 @@ dbPaintMerge(tile, newType, area, plane, mergeFlags, undo, mark)
 	    if (mark) dbMarkClient(tile, area);
 	}
 	if (BOTTOM(tp) < BOTTOM(tile)) tp = TiSplitY(tp, BOTTOM(tile));
-	TiJoinX(tile, tp, plane);
+	TiJoinX1(&delayed, tile, tp, plane);
 #ifdef	PAINTDEBUG
 	if (dbPaintDebug)
 	    dbPaintShowTile(tile, undo, "(DBMERGE) merged right");
@@ -2016,7 +2040,7 @@ dbPaintMerge(tile, newType, area, plane, mergeFlags, undo, mark)
     if (mergeFlags&MRG_TOP)
     {
 	tp = RT(tile);
-	if (CANMERGE_Y(tp, tile)) TiJoinY(tile, tp, plane);
+	if (CANMERGE_Y(tp, tile)) TiJoinY1(&delayed, tile, tp, plane);
 #ifdef	PAINTDEBUG
 	if (dbPaintDebug)
 	    dbPaintShowTile(tile, undo, "(DBMERGE) merged up");
@@ -2025,13 +2049,14 @@ dbPaintMerge(tile, newType, area, plane, mergeFlags, undo, mark)
     if (mergeFlags&MRG_BOTTOM)
     {
 	tp = LB(tile);
-	if (CANMERGE_Y(tp, tile)) TiJoinY(tile, tp, plane);
+	if (CANMERGE_Y(tp, tile)) TiJoinY1(&delayed, tile, tp, plane);
 #ifdef	PAINTDEBUG
 	if (dbPaintDebug)
 	    dbPaintShowTile(tile, undo, "(DBMERGE) merged down");
 #endif	/* PAINTDEBUG */
     }
 
+    TiFreeIf(delayed);
     return (tile);
 }
 
@@ -2094,9 +2119,10 @@ DBPaintType(plane, area, resultTbl, client, undo, tileMask)
      * search.
      */
 
+    Tile *delayed = NULL; /* delayed free to extend lifetime */
     start.p_x = area->r_xbot;
     start.p_y = area->r_ytop - 1;
-    tile = plane->pl_hint;
+    tile = PlaneGetHint(plane);
     GOTOPOINT(tile, &start);
 
     /* Each iteration visits another tile on the LHS of the search area */
@@ -2186,14 +2212,14 @@ enumerate:
 		if (CANMERGE_Y(newtile, tp) &&
 			( (TiGetClient(tp) == TiGetClient(newtile)) ||
 			( ! TTMaskHasType(tileMask, TiGetTypeExact(tp)) ) ) )
-			    TiJoinY(newtile, tp, plane);
+			    TiJoinY1(&delayed, newtile, tp, plane);
 
 		/* Merge the outside tile to its bottom */
 		tp = LB(newtile);
 		if (CANMERGE_Y(newtile, tp) &&
 			( (TiGetClient(tp) == TiGetClient(newtile)) ||
 			( ! TTMaskHasType(tileMask, TiGetTypeExact(tp)) ) ) )
-			    TiJoinY(newtile, tp, plane);
+			    TiJoinY1(&delayed, newtile, tp, plane);
 	    }
 
 	    /* Clip left */
@@ -2210,14 +2236,14 @@ enumerate:
 		if (CANMERGE_Y(newtile, tp) &&
 			( (TiGetClient(tp) == TiGetClient(newtile)) ||
 			( ! TTMaskHasType(tileMask, TiGetTypeExact(tp)) ) ) )
-			TiJoinY(newtile, tp, plane);
+			TiJoinY1(&delayed, newtile, tp, plane);
 
 		/* Merge the outside tile to its bottom */
 		tp = LB(newtile);
 		if (CANMERGE_Y(newtile, tp) &&
 			( (TiGetClient(tp) == TiGetClient(newtile)) ||
 			( ! TTMaskHasType(tileMask, TiGetTypeExact(tp)) ) ) )
-			TiJoinY(newtile, tp, plane);
+			TiJoinY1(&delayed, newtile, tp, plane);
 	    }
 
 #ifdef	PAINTDEBUG
@@ -2276,7 +2302,7 @@ enumerate:
 	{
 	    tp = RT(tile);
 	    if (CANMERGE_Y(tile, tp) && (tp->ti_client == client))
-		TiJoinY(tile, tp, plane);
+		TiJoinY1(&delayed, tile, tp, plane);
 #ifdef	PAINTDEBUG
 	    if (dbPaintDebug)
 		dbPaintShowTile(tile, undo, "merged up (CHEAP)");
@@ -2286,7 +2312,7 @@ enumerate:
 	{
 	    tp = LB(tile);
 	    if (CANMERGE_Y(tile, tp) && (tp->ti_client == client))
-		TiJoinY(tile, tp, plane);
+		TiJoinY1(&delayed, tile, tp, plane);
 #ifdef	PAINTDEBUG
 	    if (dbPaintDebug)
 		dbPaintShowTile(tile, undo, "merged down (CHEAP)");
@@ -2333,7 +2359,8 @@ paintdone:
     }
 
 done:
-    plane->pl_hint = tile;
+    PlaneSetHint(plane, tile);
+    TiFreeIf(delayed);
 }
 
 /*
@@ -2380,6 +2407,7 @@ dbMergeType(tile, newType, plane, mergeFlags, undo, client)
     PaintUndoInfo *undo;	/* See DBPaintPlane() above */
     ClientData client;
 {
+    Tile *delayed = NULL; /* delayed free to extend lifetime */
     Tile *tp, *tpLast;
     int ysplit;
 
@@ -2481,7 +2509,7 @@ dbMergeType(tile, newType, plane, mergeFlags, undo, client)
 	    TiSetClient(tpLast, client);
 	}
 	if (BOTTOM(tp) < BOTTOM(tile)) tp = TiSplitY(tp, BOTTOM(tile));
-	TiJoinX(tile, tp, plane);
+	TiJoinX1(&delayed, tile, tp, plane);
 #ifdef	PAINTDEBUG
 	if (dbPaintDebug)
 	    dbPaintShowTile(tile, undo, "(DBMERGE) merged left");
@@ -2497,7 +2525,7 @@ dbMergeType(tile, newType, plane, mergeFlags, undo, client)
 	    TiSetClient(tpLast, client);
 	}
 	if (BOTTOM(tp) < BOTTOM(tile)) tp = TiSplitY(tp, BOTTOM(tile));
-	TiJoinX(tile, tp, plane);
+	TiJoinX1(&delayed, tile, tp, plane);
 #ifdef	PAINTDEBUG
 	if (dbPaintDebug)
 	    dbPaintShowTile(tile, undo, "(DBMERGE) merged right");
@@ -2506,7 +2534,7 @@ dbMergeType(tile, newType, plane, mergeFlags, undo, client)
     if (mergeFlags&MRG_TOP)
     {
 	tp = RT(tile);
-	if (CANMERGE_Y(tp, tile) && (tp->ti_client == client)) TiJoinY(tile, tp, plane);
+	if (CANMERGE_Y(tp, tile) && (tp->ti_client == client)) TiJoinY1(&delayed, tile, tp, plane);
 #ifdef	PAINTDEBUG
 	if (dbPaintDebug)
 	    dbPaintShowTile(tile, undo, "(DBMERGE) merged up");
@@ -2515,13 +2543,14 @@ dbMergeType(tile, newType, plane, mergeFlags, undo, client)
     if (mergeFlags&MRG_BOTTOM)
     {
 	tp = LB(tile);
-	if (CANMERGE_Y(tp, tile) && (tp->ti_client == client)) TiJoinY(tile, tp, plane);
+	if (CANMERGE_Y(tp, tile) && (tp->ti_client == client)) TiJoinY1(&delayed, tile, tp, plane);
 #ifdef	PAINTDEBUG
 	if (dbPaintDebug)
 	    dbPaintShowTile(tile, undo, "(DBMERGE) merged down");
 #endif	/* PAINTDEBUG */
     }
 
+    TiFreeIf(delayed);
     return (tile);
 }
 
@@ -2581,9 +2610,10 @@ DBPaintPlaneVert(plane, area, resultTbl, undo)
      * search.
      */
 
+    Tile *delayed = NULL; /* delayed free to extend lifetime */
     start.p_x = area->r_xbot;
     start.p_y = area->r_ytop - 1;
-    tile = plane->pl_hint;
+    tile = PlaneGetHint(plane);
     GOTOPOINT(tile, &start);
 
     /* Each iteration visits another tile on the LHS of the search area */
@@ -2662,11 +2692,11 @@ enumerate:
 
 		/* Merge the outside tile to its left */
 		tp = BL(newtile);
-		if (CANMERGE_X(newtile, tp)) TiJoinX(newtile, tp, plane);
+		if (CANMERGE_X(newtile, tp)) TiJoinX1(&delayed, newtile, tp, plane);
 
 		/* Merge the outside tile to its right */
 		tp = TR(newtile);
-		if (CANMERGE_X(newtile, tp)) TiJoinX(newtile, tp, plane);
+		if (CANMERGE_X(newtile, tp)) TiJoinX1(&delayed, newtile, tp, plane);
 	    }
 
 	    /* Clip down */
@@ -2678,11 +2708,11 @@ enumerate:
 
 		/* Merge the outside tile to its left */
 		tp = BL(newtile);
-		if (CANMERGE_X(newtile, tp)) TiJoinX(newtile, tp, plane);
+		if (CANMERGE_X(newtile, tp)) TiJoinX1(&delayed, newtile, tp, plane);
 
 		/* Merge the outside tile to its right */
 		tp = TR(newtile);
-		if (CANMERGE_X(newtile, tp)) TiJoinX(newtile, tp, plane);
+		if (CANMERGE_X(newtile, tp)) TiJoinX1(&delayed, newtile, tp, plane);
 	    }
 
 #ifdef	PAINTDEBUG
@@ -2740,7 +2770,7 @@ enumerate:
 	if (mergeFlags & MRG_LEFT)
 	{
 	    tp = BL(tile);
-	    if (CANMERGE_X(tile, tp)) TiJoinX(tile, tp, plane);
+	    if (CANMERGE_X(tile, tp)) TiJoinX1(&delayed, tile, tp, plane);
 #ifdef	PAINTDEBUG
 	    if (dbPaintDebug)
 		dbPaintShowTile(tile, undo, "merged left (CHEAP)");
@@ -2749,7 +2779,7 @@ enumerate:
 	if (mergeFlags & MRG_RIGHT)
 	{
 	    tp = TR(tile);
-	    if (CANMERGE_X(tile, tp)) TiJoinX(tile, tp, plane);
+	    if (CANMERGE_X(tile, tp)) TiJoinX1(&delayed, tile, tp, plane);
 #ifdef	PAINTDEBUG
 	    if (dbPaintDebug)
 		dbPaintShowTile(tile, undo, "merged right (CHEAP)");
@@ -2796,7 +2826,8 @@ paintdone:
     }
 
 done:
-    plane->pl_hint = tile;
+    PlaneSetHint(plane, tile);
+    TiFreeIf(delayed);
     return 0;
 }
 
@@ -2849,6 +2880,7 @@ dbPaintMergeVert(tile, newType, plane, mergeFlags, undo)
     int mergeFlags;		/* Specify which directions to merge */
     PaintUndoInfo *undo;	/* See DBPaintPlane() above */
 {
+    Tile *delayed = NULL; /* delayed free to extend lifetime */
     Tile *tp, *tpLast;
     int xsplit;
 
@@ -2943,7 +2975,7 @@ dbPaintMergeVert(tile, newType, plane, mergeFlags, undo)
 	if (LEFT(tp) < LEFT(tile)) tp = TiSplitX(tp, LEFT(tile));
 	if (RIGHT(tp) > RIGHT(tile))
 	    tpLast = TiSplitX(tp, RIGHT(tile)), TiSetBody(tpLast, newType);
-	TiJoinY(tile, tp, plane);
+	TiJoinY1(&delayed, tile, tp, plane);
 #ifdef	PAINTDEBUG
 	if (dbPaintDebug)
 	    dbPaintShowTile(tile, undo, "(DBMERGE) merged up");
@@ -2956,7 +2988,7 @@ dbPaintMergeVert(tile, newType, plane, mergeFlags, undo)
 	if (LEFT(tp) < LEFT(tile)) tp = TiSplitX(tp, LEFT(tile));
 	if (RIGHT(tp) > RIGHT(tile))
 	    tpLast = TiSplitX(tp, RIGHT(tile)), TiSetBody(tpLast, newType);
-	TiJoinY(tile, tp, plane);
+	TiJoinY1(&delayed, tile, tp, plane);
 #ifdef	PAINTDEBUG
 	if (dbPaintDebug)
 	    dbPaintShowTile(tile, undo, "(DBMERGE) merged down");
@@ -2966,7 +2998,7 @@ dbPaintMergeVert(tile, newType, plane, mergeFlags, undo)
     if (mergeFlags&MRG_LEFT)
     {
 	tp = BL(tile);
-	if (CANMERGE_X(tp, tile)) TiJoinX(tile, tp, plane);
+	if (CANMERGE_X(tp, tile)) TiJoinX1(&delayed, tile, tp, plane);
 #ifdef	PAINTDEBUG
 	if (dbPaintDebug)
 	    dbPaintShowTile(tile, undo, "(DBMERGE) merged left");
@@ -2975,13 +3007,14 @@ dbPaintMergeVert(tile, newType, plane, mergeFlags, undo)
     if (mergeFlags&MRG_RIGHT)
     {
 	tp = TR(tile);
-	if (CANMERGE_X(tp, tile)) TiJoinX(tile, tp, plane);
+	if (CANMERGE_X(tp, tile)) TiJoinX1(&delayed, tile, tp, plane);
 #ifdef	PAINTDEBUG
 	if (dbPaintDebug)
 	    dbPaintShowTile(tile, undo, "(DBMERGE) merged right");
 #endif	/* PAINTDEBUG */
     }
 
+    TiFreeIf(delayed);
     return (tile);
 }
 
@@ -3004,7 +3037,7 @@ dbPaintMergeVert(tile, newType, plane, mergeFlags, undo)
  * ----------------------------------------------------------------------------
  */
 
-#include "styles.h"
+#include "utils/styles.h"
 
 void
 dbPaintShowTile(tile, undo, str)
@@ -3027,6 +3060,16 @@ dbPaintShowTile(tile, undo, str)
     TxPrintf("%s --more--", str); fflush(stdout);
     (void) TxGetLine(answer, sizeof answer);
     DBWFeedbackClear(NULL);
+
+    /* To debug tile operations that happen away from the active layout
+     * window, it may be advantageous to replace the display code above
+     * with the print statement below.
+     */
+    /*
+    TxPrintf("Debug %s: Tile (%d %d) to (%d %d) type %d\n",
+		str, LEFT(tile), BOTTOM(tile), RIGHT(tile), TOP(tile),
+		TiGetBody(tile));
+    */
 }
 #endif	/* PAINTDEBUG */
 
@@ -3316,6 +3359,7 @@ TiNMMergeRight(tile, plane)
     Tile *tile;
     Plane *plane;
 {
+    Tile *delayed = NULL; /* delayed free to extend lifetime */
     TileType ttype = TiGetTypeExact(tile);
     Tile *tp, *tp2, *newtile;
 
@@ -3347,7 +3391,7 @@ TiNMMergeRight(tile, plane)
 	    else
 		newtile = tile;
 	    // Join tp to newtile
-	    TiJoinX(newtile, tp, plane);
+	    TiJoinX1(&delayed, newtile, tp, plane);
 	}
 	tp = tp2;
     }
@@ -3364,11 +3408,13 @@ TiNMMergeRight(tile, plane)
 	    newtile = TiSplitY(tp, BOTTOM(tile));
 	    TiSetBody(newtile, ttype);
 	    // join newtile to tile
-	    TiJoinX(tile, newtile, plane);
+	    TiJoinX1(&delayed, tile, newtile, plane);
 	    // merge up if possible
-	    if (CANMERGE_Y(tile, RT(tile))) TiJoinY(tile, RT(tile), plane);
+	    if (CANMERGE_Y(tile, RT(tile))) TiJoinY1(&delayed, tile, RT(tile), plane);
 	}
     }
+
+    TiFreeIf(delayed);
     return tile;
 }
 
@@ -3396,6 +3442,7 @@ TiNMMergeLeft(tile, plane)
     Tile *tile;
     Plane *plane;
 {
+    Tile *delayed = NULL; /* delayed free to extend lifetime */
     TileType ttype = TiGetTypeExact(tile);
     Tile *tp, *tp2, *newtile;
 
@@ -3428,7 +3475,7 @@ TiNMMergeLeft(tile, plane)
 	    else
 		newtile = tile;
 	    // Join tp to tile
-	    TiJoinX(tile, tp, plane);
+	    TiJoinX1(&delayed, tile, tp, plane);
 	    tile = newtile;
 	}
 	tp = tp2;
@@ -3446,14 +3493,16 @@ TiNMMergeLeft(tile, plane)
 	    newtile = TiSplitY(tp, TOP(tile));
 	    TiSetBody(newtile, ttype);
 	    // join tp to tile
-	    TiJoinX(tile, tp, plane);
+	    TiJoinX1(&delayed, tile, tp, plane);
 	}
     }
     else
     {
 	// Merge up if possible
-	if (CANMERGE_Y(tile, tp)) TiJoinY(tile, tp, plane);
+	if (CANMERGE_Y(tile, tp)) TiJoinY1(&delayed, tile, tp, plane);
     }
+
+    TiFreeIf(delayed);
     return tile;
 }
 

database/DBpaint2.c

@@ -119,8 +119,9 @@ DBPaint (cellDef, rect, type)
  */
 
 int
-dbResolveImages(tile, cellDef)
+dbResolveImages(tile, dinfo, cellDef)
     Tile *tile;
+    TileType dinfo;
     CellDef *cellDef;
 {
     Rect rect;
@@ -130,7 +131,7 @@ dbResolveImages(tile, cellDef)
     /* Recursive call back to DBPaint---this will ensure that   */
     /* all of the planes of the image type are painted.         */
 
-    DBPaint(cellDef, &rect, TiGetTypeExact(tile));
+    DBPaint(cellDef, &rect, TiGetTypeExact(tile) | dinfo);
     return 0;
 }
 

database/DBprop.c

@@ -32,6 +32,16 @@ static char rcsid[] __attribute__ ((unused)) = "$Header: /usr/cvsroot/magic-8.0/
 #include "database/database.h"
 #include "utils/malloc.h"
 
+/* Global variable */
+
+bool DBPropCompat = TRUE;	/* If TRUE, then always save properties to
+				 * .mag files as type "string" for backwards
+				 * compatibility.  If FALSE, then properties
+				 * are saved to the .mag file along with their
+				 * type.  Regardless of the setting, properties
+				 * which are reserved keywords are converted
+				 * to the best internal representation on input.
+				 */
 
 /* ----------------------------------------------------------------------------
  *
@@ -47,16 +57,16 @@ static char rcsid[] __attribute__ ((unused)) = "$Header: /usr/cvsroot/magic-8.0/
 
 void
 DBPropPut(cellDef, name, value)
-    CellDef *cellDef;	/* Pointer to definition of cell. */
-    char *name;		/* The name of the property desired. */
-    ClientData value;	/* MUST point to a malloc'ed structure, or NULL.
-			 * This will be freed when the CellDef is freed.
-			 */
+    CellDef *cellDef;		/* Pointer to definition of cell. */
+    char *name;			/* The name of the property desired. */
+    PropertyRecord *value;	/* MUST point to a malloc'ed structure, or NULL.
+				 * This will be freed when the CellDef is freed.
+				 */
 
 {
     HashTable *htab;
     HashEntry *entry;
-    char *oldvalue;
+    PropertyRecord *oldvalue;
 
     /* Honor the NOEDIT flag.  Note that the caller always assumes that */
     /* the value would be saved in the hash table, so if it is not	*/
@@ -95,12 +105,23 @@ DBPropPut(cellDef, name, value)
     }
 
     entry = HashFind(htab, name);
-    oldvalue = (char *)HashGetValue(entry);
-    if (oldvalue != NULL) freeMagic(oldvalue);
-    if (value == (ClientData)NULL)
+    oldvalue = (PropertyRecord *)HashGetValue(entry);
+    /* All properties are allocated as a single block and can just be freed,
+     * except for plane properties, which require freeing the plane.
+     */
+    if (oldvalue != NULL)
+    {
+	if (oldvalue->prop_type == PROPERTY_TYPE_PLANE)
+	{
+	    DBFreePaintPlane(oldvalue->prop_value.prop_plane);
+	    TiFreePlane(oldvalue->prop_value.prop_plane);
+	}
+	freeMagic((char *)oldvalue);
+    }
+    if (value == (PropertyRecord *)NULL)
 	HashRemove(htab, name);
     else
-	HashSetValue(entry, value);
+	HashSetValue(entry, PTR2CD(value));
 }
 
 /* ----------------------------------------------------------------------------
@@ -110,13 +131,13 @@ DBPropPut(cellDef, name, value)
  * Get a property from a celldef.
  *
  * Results:
- *	NULL if the property didn't exist, or if the property value was NULL.
- *	Otherwise, ClientData that represents the property.
+ *	NULL if the property didn't exist, or if the property record was NULL.
+ *	Otherwise, returns a pointer to the property record.
  *
  * ----------------------------------------------------------------------------
  */
 
-ClientData
+PropertyRecord *
 DBPropGet(cellDef, name, found)
     CellDef *cellDef;	/* Pointer to definition of cell. */
     char *name;		/* The name of the property desired. */
@@ -124,12 +145,12 @@ DBPropGet(cellDef, name, found)
 			 * exists.
 			 */
 {
-    ClientData result;
+    PropertyRecord *result;
     bool haveit;
     HashTable *htab;
     HashEntry *entry;
 
-    result = (ClientData) NULL;
+    result = (PropertyRecord *)NULL;
     haveit = FALSE;
     htab = (HashTable *) cellDef->cd_props;
     if (htab == (HashTable *) NULL) goto done;
@@ -138,7 +159,7 @@ DBPropGet(cellDef, name, found)
     if (entry != NULL)
     {
 	haveit = TRUE;
-	result = (ClientData) HashGetValue(entry);
+	result = (PropertyRecord *)HashGetValue(entry);
     }
 
 done:
@@ -146,6 +167,109 @@ done:
     return result;
 }
 
+/* ----------------------------------------------------------------------------
+ *
+ * DBPropGetString --
+ *
+ * Get a string property from a celldef.
+ *
+ * Results:
+ *	NULL if the property didn't exist, or if the property record was NULL.
+ *	Otherwise, returns a pointer to the property's string record.
+ *
+ * Notes:
+ *	This is basically the original DBPropGet(), when properties were only
+ *	allowed to be strings.
+ *
+ * ----------------------------------------------------------------------------
+ */
+
+char *
+DBPropGetString(cellDef, name, found)
+    CellDef *cellDef;	/* Pointer to definition of cell. */
+    char *name;		/* The name of the property desired. */
+    bool *found;	/* If not NULL, filled in with TRUE iff the property
+			 * exists.
+			 */
+{
+    char *result = NULL;
+    PropertyRecord *proprec;
+    bool haveit;
+    HashTable *htab;
+    HashEntry *entry;
+
+    haveit = FALSE;
+    htab = (HashTable *) cellDef->cd_props;
+    if (htab == (HashTable *) NULL) goto pdone;
+
+    entry = HashLookOnly(htab, name);
+    if (entry != NULL)
+    {
+	proprec = (PropertyRecord *)HashGetValue(entry);
+	if (proprec->prop_type == PROPERTY_TYPE_STRING)
+	{
+	    haveit = TRUE;
+	    result = proprec->prop_value.prop_string;
+	}
+    }
+
+pdone:
+    if (found != (bool *) NULL) *found = haveit;
+    return result;
+}
+
+/* ----------------------------------------------------------------------------
+ *
+ * DBPropGetDouble --
+ *
+ * Get a single double-long integer property from a celldef.
+ *
+ * Results:
+ *	NULL if the property didn't exist, or if the property record was NULL.
+ *	Otherwise, returns a pointer to the property's value record.
+ *
+ * ----------------------------------------------------------------------------
+ */
+
+dlong
+DBPropGetDouble(cellDef, name, found)
+    CellDef *cellDef;	/* Pointer to definition of cell. */
+    char *name;		/* The name of the property desired. */
+    bool *found;	/* If not NULL, filled in with TRUE iff the property
+			 * exists.
+			 */
+{
+    dlong result = 0;
+    PropertyRecord *proprec;
+    bool haveit;
+    HashTable *htab;
+    HashEntry *entry;
+
+    haveit = FALSE;
+    htab = (HashTable *) cellDef->cd_props;
+    if (htab == (HashTable *) NULL) goto ddone;
+
+    entry = HashLookOnly(htab, name);
+    if (entry != NULL)
+    {
+	proprec = (PropertyRecord *)HashGetValue(entry);
+	if (proprec->prop_type == PROPERTY_TYPE_DOUBLE)
+	{
+	    haveit = TRUE;
+	    result = proprec->prop_value.prop_double[0];
+	}
+	else if (proprec->prop_type == PROPERTY_TYPE_STRING)
+	{
+	    haveit = TRUE;
+	    sscanf(proprec->prop_value.prop_string, "%"DLONG_PREFIX"d", &result);
+	}
+    }
+
+ddone:
+    if (found != (bool *) NULL) *found = haveit;
+    return result;
+}
+
 /* ----------------------------------------------------------------------------
  *
  * DBPropEnum --
@@ -168,7 +292,7 @@ DBPropEnum(cellDef, func, cdata)
 			 *
 			 *	int foo(name, value, cdata)
 			 *	    char *name;
-			 *	    ClientData value;
+			 *	    PropertyRecord *value;
 			 *	    ClientData cdata;
 			 *	{
 			 *	    -- return 0 to continue,
@@ -189,7 +313,7 @@ DBPropEnum(cellDef, func, cdata)
     HashStartSearch(&hs);
     while ((entry = HashNext(htab, &hs)) != NULL)
     {
-	res = (*func)(entry->h_key.h_name, (ClientData) entry->h_pointer, cdata);
+	res = (*func)(entry->h_key.h_name, (PropertyRecord *)entry->h_pointer, cdata);
 	if (res != 0) return res;
     }
 

database/DBtechname.c

@@ -327,11 +327,11 @@ DBTechNoisyNamePlane(planename)
  * ----------------------------------------------------------------------------
  */
 
-char *
-DBTypeShortName(type)
-    TileType type;
+const char *
+DBTypeShortName(
+    TileType type)
 {
-    NameList *tbl;
+    const NameList *tbl;
 
     for (tbl = dbTypeNameLists.sn_next;
 	    tbl != &dbTypeNameLists;
@@ -347,11 +347,11 @@ DBTypeShortName(type)
     return ("???");
 }
 
-char *
-DBPlaneShortName(pNum)
-    int pNum;
+const char *
+DBPlaneShortName(
+    int pNum)
 {
-    NameList *tbl;
+    const NameList *tbl;
 
     for (tbl = dbPlaneNameLists.sn_next;
 	    tbl != &dbPlaneNameLists;
@@ -478,7 +478,7 @@ DBTechPrintTypes(mask, dolist)
 #ifdef MAGIC_WRAPPER
 		Tcl_AppendResult(magicinterp, " ", (char *)NULL);
 #else
-		TxPrintf(" ", keepname);
+		TxPrintf(" ");
 #endif
 	    }
 	}
@@ -530,7 +530,7 @@ DBTechPrintTypes(mask, dolist)
 #ifdef MAGIC_WRAPPER
 		    Tcl_AppendResult(magicinterp, " ", (char *)NULL);
 #else
-		    TxPrintf(" ", keepname);
+		    TxPrintf(" ");
 #endif
 		}
 	    }

database/DBtechtype.c

@@ -38,14 +38,14 @@ static char rcsid[] __attribute__ ((unused)) = "$Header: /usr/cvsroot/magic-8.0/
 
     /* Types and their names */
 int DBNumTypes;
-char *DBTypeLongNameTbl[NT];
+const char *DBTypeLongNameTbl[NT];
 int DBTypePlaneTbl[NT];		/* Normally accessed as macro "DBPlane(x)" */
 NameList dbTypeNameLists = {NULL, NULL, NULL, (ClientData)0, FALSE};
 HashTable DBTypeAliasTable;
 
     /* Planes and their names */
 int DBNumPlanes;
-char *DBPlaneLongNameTbl[PL_MAXTYPES];
+const char *DBPlaneLongNameTbl[PL_MAXTYPES];
 NameList dbPlaneNameLists = {NULL, NULL, NULL, (ClientData)0, FALSE};
 
 
@@ -116,22 +116,24 @@ NameList *dbTechNameAddOne();
  */
 
 void
-DBTechInitPlane()
+DBTechInitPlane(void)
 {
     DefaultPlane *dpp;
-    char *cp;
+    const char *cp;
 
     /* Clear out any old information */
     if (dbPlaneNameLists.sn_next != NULL)
     {
 	NameList *tbl;
 
+	free_magic1_t mm1 = freeMagic1_init();
 	for (tbl = dbPlaneNameLists.sn_next; tbl != &dbPlaneNameLists;
 			tbl = tbl->sn_next)
 	{
 	    freeMagic(tbl->sn_name);
-	    freeMagic(tbl);
+	    freeMagic1(&mm1, tbl);
 	}
+	freeMagic1_end(&mm1);
     }
 
     /* Tables of short names */
@@ -205,12 +207,14 @@ DBTechInitType()
     {
 	NameList *tbl;
 
+	free_magic1_t mm1 = freeMagic1_init();
 	for (tbl = dbTypeNameLists.sn_next; tbl != &dbTypeNameLists;
 		tbl = tbl->sn_next)
 	{
 	    freeMagic(tbl->sn_name);
-	    freeMagic(tbl);
+	    freeMagic1(&mm1, tbl);
 	}
+	freeMagic1_end(&mm1);
     }
 
     /* Tables of short names */
@@ -264,12 +268,12 @@ DBTechInitType()
 
     /*ARGSUSED*/
 bool
-DBTechAddPlane(sectionName, argc, argv)
-    char *sectionName;
-    int argc;
-    char *argv[];
+DBTechAddPlane(
+    const char *sectionName,
+    int argc,
+    char *argv[])
 {
-    char *cp;
+    const char *cp;
 
     if (DBNumPlanes >= PL_MAXTYPES)
     {

database/DBtiles.c

@@ -44,6 +44,296 @@ struct dbCheck
 
 int dbCheckMaxHFunc(), dbCheckMaxVFunc();
 
+/*
+ * --------------------------------------------------------------------
+ *
+ * dbEvalCorner --
+ *
+ *	Used by DBTestNMInteract() to determine whether two non-
+ *	Manhattan areas have crossing diagonals by evaluating the
+ *	corner points of the area of intersection between the two
+ *	tiles.  This routine finds the distance from a point in
+ *	the second triangle to the diagonal of the first, in both
+ *	x and y.  If the point is below or to the left, the
+ *	distance is negative;  otherwise the distance is positive.
+ *
+ * Results:
+ *	1 for a positive result, -1 for a negative result, and 0
+ *	for the same result (point touches the diagonal).
+ *
+ * Side effects:
+ *	None.
+ *
+ * --------------------------------------------------------------------
+ */
+
+int
+dbEvalCorner(Point *p,	// Point to evaluate
+    Rect *rect,		// Triangular area bounding rectangle
+    TileType di)	// Diagonal information for split rect
+{
+    dlong D;
+
+    /* D is the distance from a point to the diagonal of the rectangle.
+     * The magnitude is not important.  It only matters what the sign
+     * is, so return 1 for positive, -1 for negative, or 0.
+     */
+
+    if (di & TT_DIRECTION)
+	D = (p->p_y - rect->r_ybot) * (rect->r_xtop - rect->r_xbot) -
+		(rect->r_xtop - p->p_x) * (rect->r_ytop - rect->r_ybot);
+    else
+	D = (p->p_y - rect->r_ybot) * (rect->r_xtop - rect->r_xbot) -
+		(p->p_x - rect->r_xbot) * (rect->r_ytop - rect->r_ybot);
+
+    if (D > 0) return 1;
+    if (D < 0) return -1;
+    return 0;
+}
+
+/*
+ * --------------------------------------------------------------------
+ *
+ * DBTestNMInteract --
+ *
+ *	Determine if a tile (t2) interacts with (touches or overlaps)
+ *	a triangular area (rect1, with diagonal split information in
+ *	di1).  Tile t2 may or may not be a split tile.  If t2 is
+ *	split, then diagonal split information is in di2.
+ *
+ *	There are two distinct cases:  DBSrPaintNMArea() looks for
+ *	tiles that overlap the area of rect1, but extTestNMInteract()
+ *	looks for tiles that both overlap or touch (indicating
+ *	electrical connectivity between the two).  "overlap_only"
+ *	distinguishes between the two use cases.  Set "overlap_only"
+ *	to TRUE for overlap searches, and FALSE for interaction
+ *	searches.
+ *
+ * Results:
+ *	
+ *	If overlap_only is TRUE:
+ *	    Return TRUE if the indicated areas overlap, FALSE if not.
+ *	If overlap_only is FALSE:
+ *	    Return TRUE if the indicated areas touch or overlap, FALSE if not.
+ *
+ * Side effects:
+ *	None.
+ *
+ * --------------------------------------------------------------------
+ */
+
+bool
+DBTestNMInteract(Rect *rect1,
+    TileType tt1,
+    Tile *t2,
+    TileType di2,
+    bool overlap_only)
+{
+    Rect rect2, r;
+    Point p;
+    int rheight, rwidth, rmax;
+    dlong f1, f2, f3, f4;
+    TileType tt2;
+    int pos, neg, touch, sign;
+
+    TiToRect(t2, &rect2);
+
+    /* Assuming that rect1 is a split area, then check if any part of t2
+     * overlaps the split side of interest in rect1, regardless of whether
+     * t2 is split or not.  If there is no overlap, then return FALSE.
+     */
+
+    rheight = rect1->r_ytop - rect1->r_ybot;
+    rwidth = rect1->r_xtop - rect1->r_xbot;
+    rmax = MAX(rheight, rwidth);
+
+    f1 = (rect2.r_ybot > MINFINITY + 2) ?
+                ((dlong)(rect1->r_ytop - rect2.r_ybot) * rwidth) : DLONG_MAX;
+    f2 = (rect2.r_ytop < INFINITY - 2) ?
+                ((dlong)(rect2.r_ytop - rect1->r_ybot) * rwidth) : DLONG_MAX;
+
+    if (tt1 & TT_SIDE)
+    {
+        /* Outside-of-triangle check---ignore sub-integer slivers */
+        if (rect2.r_xtop < INFINITY - 2)
+        {
+            f3 = (dlong)(rect1->r_xtop - rect2.r_xtop) * rheight;
+            f3 += rmax;
+        }
+        else
+            f3 = DLONG_MIN;
+        if ((tt1 & TT_DIRECTION) ? (f2 < f3) : (f1 < f3))
+            return FALSE;
+    }
+    else
+    {
+        /* Outside-of-triangle check---ignore sub-integer slivers */
+        if (rect2.r_xbot > MINFINITY + 2)
+        {
+            f4 = (dlong)(rect2.r_xbot - rect1->r_xbot) * rheight;
+            f4 += rmax;
+        }
+        else
+            f4 = DLONG_MIN;
+        if ((tt1 & TT_DIRECTION) ? (f1 < f4) : (f2 < f4))
+            return FALSE;
+    }
+
+    /* If t2 is not split, or its diagonal is the opposite of t1,
+     * or its side is the same as that of t1, then they overlap.
+     */
+    if (!IsSplit(t2)) return TRUE;
+
+    tt2 = TiGetTypeExact(t2) | di2;
+
+    if ((tt1 & TT_DIRECTION) != (tt2 & TT_DIRECTION)) return TRUE;
+    // if ((tt1 & TT_SIDE) == (tt2 & TT_SIDE)) return TRUE;
+
+    /* Hard case:  Same diagonal direction, opposite sides.  To determine
+     * overlap, count which of the three points of triangle t2 land on
+     * one side or the other of the rect1 split diagonal.  From those
+     * counts, determine if the triangles are overlapping, touching,
+     * or disjoint.
+     */
+
+    /* Evaluate the three corners of the rect2 triangle */
+    
+    pos = neg = touch = 0;
+    if (!(tt2 & TT_DIRECTION) || !(tt2 & TT_SIDE))
+    {
+	/* Evaluate the lower left corner */
+	sign = dbEvalCorner(&rect2.r_ll, rect1, tt1);
+	if (sign == 1)
+	    pos++;
+	else if (sign == -1)
+	    neg++;
+	else
+	    touch++;
+    }
+    
+    if (!(tt2 & TT_DIRECTION) || (tt2 & TT_SIDE))
+    {
+	/* Evaluate the upper right corner */
+	sign = dbEvalCorner(&rect2.r_ur, rect1, tt1);
+	if (sign == 1)
+	    pos++;
+	else if (sign == -1)
+	    neg++;
+	else
+	    touch++;
+    }
+
+    if ((tt2 & TT_DIRECTION) || !(tt2 & TT_SIDE))
+    {
+	/* Evaluate the upper left corner */
+	p.p_x = rect2.r_xbot;
+	p.p_y = rect2.r_ytop;
+	sign = dbEvalCorner(&p, rect1, tt1);
+	if (sign == 1)
+	    pos++;
+	else if (sign == -1)
+	    neg++;
+	else
+	    touch++;
+    }
+
+    if ((tt2 & TT_DIRECTION) || (tt2 & TT_SIDE))
+    {
+	/* Evaluate the lower right corner */
+	p.p_x = rect2.r_xtop;
+	p.p_y = rect2.r_ybot;
+	sign = dbEvalCorner(&p, rect1, tt1);
+	if (sign == 1)
+	    pos++;
+	else if (sign == -1)
+	    neg++;
+	else
+	    touch++;
+    }
+
+    /* If side and direction match, then pos and neg need to be swapped */
+    if (((tt1 & TT_SIDE) && (tt1 & TT_DIRECTION)) ||
+		(!(tt1 & TT_SIDE) && !(tt1 & TT_DIRECTION)))
+    {
+	int temp = neg;
+	neg = pos;
+	pos = temp;
+    }
+
+    /* Return TRUE or FALSE depending on the values of pos, neg, and
+     * touch, and depending on whether overlap_only is set or not.
+     */
+    if (pos == 3)
+	return FALSE;		/* Fully disjoint */
+    else if (neg == 3)
+    {
+	if ((tt1 & TT_SIDE) != (tt2 & TT_SIDE))
+	    return TRUE;		/* Fully enclosed */
+	else
+	{
+	    /* This is a trickier situation.  Both triangles have
+	     * the same TT_SIDE bit, but the triangular area of t2
+	     * could still be outside of rect1.  Need to check where
+	     * the inside corner of rect1 lands with respect to the
+	     * t2 diagonal.
+	     */
+	    if (((tt1 & TT_SIDE) == 0) && ((tt1 & TT_DIRECTION) != 0))
+	    {
+		sign = dbEvalCorner(&rect1->r_ll, &rect2, tt2);
+	    }
+	    else if (((tt1 & TT_SIDE) == 0) && ((tt1 & TT_DIRECTION) == 0))
+	    {
+		p.p_x = rect1->r_ll.p_x;
+		p.p_y = rect1->r_ur.p_y;
+		sign = dbEvalCorner(&p, &rect2, tt2);
+	    }
+	    else if (((tt1 & TT_SIDE) != 0) && ((tt1 & TT_DIRECTION) == 0))
+	    {
+		p.p_x = rect1->r_ur.p_x;
+		p.p_y = rect1->r_ll.p_y;
+		sign = dbEvalCorner(&p, &rect2, tt2);
+	    }
+	    else /* if (((tt1 & TT_SIDE) != 0) && ((tt1 & TT_DIRECTION) != 0)) */
+	    {
+		sign = dbEvalCorner(&rect1->r_ur, &rect2, tt2);
+	    }
+
+	    /* Again, if side and direction match, then sign is backwards
+	     */
+	    if (((tt2 & TT_SIDE) && (tt2 & TT_DIRECTION)) ||
+			(!(tt2 & TT_SIDE) && !(tt2 & TT_DIRECTION)))
+		sign = -sign;
+
+	    if (sign == 1)
+	 	return FALSE;		/* Fully disjoint */
+	    else if (sign == -1)
+	 	return TRUE;		/* Fully overlapping */
+	    else if (overlap_only)
+		return FALSE;		/* Touching but not overlapping */
+	    else
+		return TRUE;		/* Touching but not overlapping */
+	}
+    }
+    else if (overlap_only)
+    {
+	if ((touch > 0) && (neg + touch == 3))
+	    return TRUE;	/* Enclosed and touching */
+	else if ((touch > 0) && (pos + touch == 3))
+	    return FALSE;	/* Unenclosed but touching */
+	else
+	    return TRUE;	/* Partially overlapping */
+    }
+    else	/* overlap_only == FALSE */
+    {
+	if ((touch > 0) && (neg + touch == 3))
+	    return TRUE;	/* Enclosed and touching */
+	else if ((touch > 0) && (pos + touch == 3))
+	    return TRUE;	/* Unenclosed but touching */
+	else
+	    return TRUE;	/* Partially overlapping */
+    }
+}
+
 /*
  * --------------------------------------------------------------------
  *
@@ -56,6 +346,7 @@ int dbCheckMaxHFunc(), dbCheckMaxVFunc();
  *	int
  *	func(tile, cdata)
  *	    Tile *tile;
+ *	    TileType dinfo;
  *	    ClientData cdata;
  *	{
  *	}
@@ -92,7 +383,7 @@ DBSrPaintNMArea(hintTile, plane, ttype, rect, mask, func, arg)
 				 * provide a hint tile in case hintTile == NULL.
 				 * The hint tile in the plane is updated to be
 				 * the last tile visited in the area
-				 * enumeration.
+				 * enumeration, if plane is non-NULL.
 				 */
     TileType ttype;		/* Information about the non-manhattan area to
 			 	 * search; zero if area is manhattan.
@@ -111,7 +402,7 @@ DBSrPaintNMArea(hintTile, plane, ttype, rect, mask, func, arg)
     TileType tpt;
     int rheight, rwidth, rmax;
     dlong f1, f2, f3, f4;
-    bool ignore_sides;
+    int ignore_sides;
 
     /* If the search area is not diagonal, return the result of the	*/
     /* standard (manhattan) search function.				*/
@@ -121,7 +412,7 @@ DBSrPaintNMArea(hintTile, plane, ttype, rect, mask, func, arg)
 
     start.p_x = rect->r_xbot;
     start.p_y = rect->r_ytop - 1;
-    tp = hintTile ? hintTile : plane->pl_hint;
+    tp = hintTile ? hintTile : PlaneGetHint(plane);
     GOTOPOINT(tp, &start);
 
     /* Each iteration visits another tile on the LHS of the search area */
@@ -129,7 +420,7 @@ DBSrPaintNMArea(hintTile, plane, ttype, rect, mask, func, arg)
     {
 	/* Each iteration enumerates another tile */
 nm_enum:
-	plane->pl_hint = tp;
+	if (plane != (Plane *)NULL) PlaneSetHint(plane, tp);
 	if (SigInterruptPending)
 	    return (1);
 
@@ -137,147 +428,26 @@ nm_enum:
 	/* the tile enumeration if it is not.				 */
 	/* Watch for calculations involving (M)INFINITY in tile (tp)!	 */
 
-	rheight = rect->r_ytop - rect->r_ybot;
-	rwidth = rect->r_xtop - rect->r_xbot;
-	rmax = MAX(rheight, rwidth);
-	f1 = (BOTTOM(tp) > MINFINITY + 2) ?
-		((dlong)(rect->r_ytop - BOTTOM(tp)) * rwidth) : DLONG_MAX;
-	f2 = (TOP(tp) < INFINITY - 2) ?
-		((dlong)(TOP(tp) - rect->r_ybot) * rwidth) : DLONG_MAX;
-
-	if (ttype & TT_SIDE)
-	{
-	    /* Outside-of-triangle check---ignore sub-integer slivers */
-	    if (RIGHT(tp) < INFINITY - 2)
-	    {
-		f3 = (dlong)(rect->r_xtop - RIGHT(tp)) * rheight;
-		f3 += rmax;
-	    }
-	    else
-		f3 = DLONG_MIN;
-	    if ((ttype & TT_DIRECTION) ? (f2 < f3) : (f1 < f3))
-		goto enum_next;
-	}
-	else
-	{
-	    /* Outside-of-triangle check---ignore sub-integer slivers */
-	    if (LEFT(tp) > MINFINITY + 2)
-	    {
-		f4 = (dlong)(LEFT(tp) - rect->r_xbot) * rheight;
-		f4 += rmax;
-	    }
-	    else
-		f4 = DLONG_MIN;
-	    if ((ttype & TT_DIRECTION) ? (f1 < f4) : (f2 < f4))
-		goto enum_next;
-	}
-
-	/* Secondary checks---if tile is also non-Manhattan, is		*/
-	/* either side of it outside the area?  If so, restrict it.	*/
-	/* This check is only necessary if the split directions are	*/
-	/* the same, so we have to see if either of the neighboring	*/
-	/* points is also inside the search triangle.			*/
-
-	ignore_sides = 0;
-
 	if (IsSplit(tp))
 	{
-	    if (!TTMaskHasType(mask, SplitLeftType(tp)))
-		ignore_sides |= IGNORE_LEFT;
-	    if (!TTMaskHasType(mask, SplitRightType(tp)))
-		ignore_sides |= IGNORE_RIGHT;
+	    TileType tpdi = TiGetTypeExact(tp);
 
-	    tpt = TiGetTypeExact(tp);
-	    if ((tpt & TT_DIRECTION) == (ttype & TT_DIRECTION))
-	    {
-		f3 = (LEFT(tp) > MINFINITY + 2) ?
-			((dlong)(rect->r_xtop - LEFT(tp)) * rheight) : DLONG_MAX;
-		f4 = (RIGHT(tp) < INFINITY - 2) ?
-			((dlong)(RIGHT(tp) - rect->r_xbot) * rheight) : DLONG_MAX;
-
-		if (ttype & TT_SIDE)
-		{
-		    /* Ignore sub-integer slivers */
-		    if (f4 != DLONG_MAX) f4 -= rmax;
-		    if (f3 != DLONG_MAX) f3 += rmax;
-
-		    if (ttype & TT_DIRECTION)
-		    {
-			if ((f2 < f3) && (f1 > f4))
-			    /* Tile bottom left is outside search area */
-			    ignore_sides |= IGNORE_LEFT;
-		    }
-		    else
-		    {
-			if ((f1 < f3) && (f2 > f4))
-			    /* Tile top left is outside search area */
-			    ignore_sides |= IGNORE_LEFT;
-		    }
-		}
-		else
-		{
-		    /* Ignore sub-integer slivers */
-		    if (f4 != DLONG_MAX) f4 += rmax;
-		    if (f3 != DLONG_MAX) f3 -= rmax;
-
-		    if (ttype & TT_DIRECTION)
-		    {
-			if ((f2 > f3) && (f1 < f4))
-			    /* Tile top right is outside search area */
-			    ignore_sides |= IGNORE_RIGHT;
-		    }
-		    else
-		    {
-			if ((f1 > f3) && (f2 < f4))
-			    /* Tile bottom right is outside search area */
-			    ignore_sides |= IGNORE_RIGHT;
-		    }
-		}
-	    }
-
-	    /* If the tile is larger than the search area or overlaps	*/
-	    /* the search area, we need to check if one of the sides	*/
-	    /* of the tile is disjoint from the search area.		*/
-
-	    rheight = TOP(tp) - BOTTOM(tp);
-	    rwidth = RIGHT(tp) - LEFT(tp);
-	    rmax = MAX(rheight, rwidth);
-	    f1 = (TOP(tp) < INFINITY - 2) ?
-			((dlong)(TOP(tp) - rect->r_ybot) * rwidth) : DLONG_MAX;
-	    f2 = (BOTTOM(tp) > MINFINITY + 2) ?
-			((dlong)(rect->r_ytop - BOTTOM(tp)) * rwidth) : DLONG_MAX;
-	    f3 = (RIGHT(tp) < INFINITY - 2) ?
-			((dlong)(RIGHT(tp) - rect->r_xtop) * rheight) : DLONG_MAX;
-	    f4 = (LEFT(tp) > MINFINITY + 2) ?
-			((dlong)(rect->r_xbot - LEFT(tp)) * rheight) : DLONG_MAX;
-
-	    /* ignore sub-integer slivers */
-	    if (f4 < DLONG_MAX) f4 += rmax;
-	    if (f3 < DLONG_MAX) f3 += rmax;
-
-	    if (SplitDirection(tp) ? (f1 < f4) : (f2 < f4))
-		ignore_sides |= IGNORE_LEFT;
-
-	    if (SplitDirection(tp) ? (f2 < f3) : (f1 < f3))
-		ignore_sides |= IGNORE_RIGHT;
-
-	    /* May call function twice to paint both sides of   */
-	    /* the split tile, if necessary.                    */
-
-	    if (!(ignore_sides & IGNORE_LEFT))
-	    {
-		TiSetBody(tp, INT2CD(tpt & ~TT_SIDE)); /* bit clear */
-		if ((*func)(tp, arg)) return (1);
-	    }
-	    if (!(ignore_sides & IGNORE_RIGHT))
-	    {
-		TiSetBody(tp, INT2CD(tpt | TT_SIDE)); /* bit set */
-		if ((*func)(tp, arg)) return (1);
-	    }
-        }
+	    if (TTMaskHasType(mask, SplitLeftType(tp)))
+		if (DBTestNMInteract(rect, ttype, tp, tpdi, TRUE))
+		    if ((*func)(tp, (TileType)TT_DIAGONAL, arg))
+			return 1;
+	    if (TTMaskHasType(mask, SplitRightType(tp)))
+		if (DBTestNMInteract(rect, ttype, tp, tpdi | TT_SIDE, TRUE))
+		    if ((*func)(tp, (TileType)TT_DIAGONAL | TT_SIDE, arg))
+			return 1;
+	}
 	else
-	    if (TTMaskHasType(mask, TiGetType(tp)) && (*func)(tp, arg))
-		return (1);
+	{
+	    if (TTMaskHasType(mask, TiGetType(tp)))
+		if (DBTestNMInteract(rect, ttype, tp, (TileType)0, TRUE))
+		    if ((*func)(tp, (TileType)0, arg))
+			return 1;
+	}
 
 enum_next:
 	tpnew = TR(tp);
@@ -325,6 +495,7 @@ enum_next:
  *	int
  *	func(tile, cdata)
  *	    Tile *tile;
+ *	    TileType dinfo;
  *	    ClientData cdata;
  *	{
  *	}
@@ -372,7 +543,7 @@ DBSrPaintArea(hintTile, plane, rect, mask, func, arg)
 
     start.p_x = rect->r_xbot;
     start.p_y = rect->r_ytop - 1;
-    tp = hintTile ? hintTile : plane->pl_hint;
+    tp = hintTile ? hintTile : PlaneGetHint(plane);
     GOTOPOINT(tp, &start);
 
     /* Each iteration visits another tile on the LHS of the search area */
@@ -380,7 +551,7 @@ DBSrPaintArea(hintTile, plane, rect, mask, func, arg)
     {
 	/* Each iteration enumerates another tile */
 enumerate:
-	plane->pl_hint = tp;
+	PlaneSetHint(plane, tp);
 	if (SigInterruptPending)
 	    return (1);
 
@@ -416,9 +587,7 @@ enumerate:
 			(dlong)(rect->r_xbot - LEFT(tp)) * theight : DLONG_MIN;
 		if (SplitDirection(tp) ? (f1 > f4) : (f2 > f4))
 		{
-		    TiSetBody(tp, INT2CD((TileType)CD2INT(TiGetBody(tp))
-				& ~TT_SIDE));  /* bit clear */
-		    if ((*func)(tp, arg)) return (1);
+		    if ((*func)(tp, (TileType)TT_DIAGONAL, arg)) return (1);
 		}
 	    }
 
@@ -429,14 +598,12 @@ enumerate:
 			(dlong)(RIGHT(tp) - rect->r_xtop) * theight : DLONG_MIN;
 		if (SplitDirection(tp) ? (f2 > f3) : (f1 > f3))
 		{
-		    TiSetBody(tp, INT2CD((TileType)CD2INT(TiGetBody(tp))
-				| TT_SIDE));      /* bit set */
-		    if ((*func)(tp, arg)) return (1);
+		    if ((*func)(tp, (TileType)TT_DIAGONAL | TT_SIDE, arg)) return (1);
 		}
 	    }
 	}
 	else
-	    if (TTMaskHasType(mask, TiGetType(tp)) && (*func)(tp, arg))
+	    if (TTMaskHasType(mask, TiGetType(tp)) && (*func)(tp, (TileType)0, arg))
 		return (1);
 
 	tpnew = TR(tp);
@@ -485,6 +652,7 @@ enumerate:
  *	int
  *	func(tile, cdata)
  *	    Tile *tile;
+ *	    TileType dinfo;
  *	    ClientData cdata;
  *	{
  *	}
@@ -532,7 +700,7 @@ DBSrPaintClient(hintTile, plane, rect, mask, client, func, arg)
 
     start.p_x = rect->r_xbot;
     start.p_y = rect->r_ytop - 1;
-    tp = hintTile ? hintTile : plane->pl_hint;
+    tp = hintTile ? hintTile : PlaneGetHint(plane);
     GOTOPOINT(tp, &start);
 
     /* Each iteration visits another tile on the LHS of the search area */
@@ -540,7 +708,7 @@ DBSrPaintClient(hintTile, plane, rect, mask, client, func, arg)
     {
 	/* Each iteration enumerates another tile */
 enumerate:
-	plane->pl_hint = tp;
+	PlaneSetHint(plane, tp);
 	if (SigInterruptPending)
 	    return (1);
 
@@ -576,9 +744,7 @@ enumerate:
 			(dlong)(rect->r_xbot - LEFT(tp)) * (dlong)theight : DLONG_MIN;
 		if (SplitDirection(tp) ? (f1 > f4) : (f2 > f4))
 		{
-		    TiSetBody(tp, INT2CD((TileType)CD2INT(TiGetBody(tp))
-				& ~TT_SIDE));  /* bit clear */
-		    if ((tp->ti_client == client) && (*func)(tp, arg))
+		    if ((tp->ti_client == client) && (*func)(tp, (TileType)TT_DIAGONAL, arg))
 			return (1);
 		}
 	    }
@@ -590,16 +756,15 @@ enumerate:
 			(dlong)(RIGHT(tp) - rect->r_xtop) * (dlong)theight : DLONG_MIN;
 		if (SplitDirection(tp) ? (f2 > f3) : (f1 > f3))
 		{
-		    TiSetBody(tp, INT2CD((TileType)CD2INT(TiGetBody(tp))
-				| TT_SIDE));      /* bit set */
-		    if ((tp->ti_client == client) && (*func)(tp, arg))
+		    if ((tp->ti_client == client) && (*func)(tp, (TileType)TT_DIAGONAL
+				| TT_SIDE, arg))
 			return (1);
 		}
 	    }
 	}
 	else
 	    if (TTMaskHasType(mask, TiGetType(tp)) && tp->ti_client == client
-				&& (*func)(tp, arg))
+				&& (*func)(tp, (TileType)0, arg))
 		return (1);
 
 	tpnew = TR(tp);
@@ -657,7 +822,7 @@ DBResetTilePlane(plane, cdata)
     ClientData cdata;
 {
     Tile *tp, *tpnew;
-    Rect *rect = &TiPlaneRect;
+    const Rect *rect = &TiPlaneRect;
 
     /* Start with the leftmost non-infinity tile in the plane */
     tp = TR(plane->pl_left);
@@ -665,7 +830,7 @@ DBResetTilePlane(plane, cdata)
     /* Each iteration visits another tile on the LHS of the search area */
     while (TOP(tp) > rect->r_ybot)
     {
-	/* Each iteration frees another tile */
+	/* Each iteration resets another tile */
 enumerate:
 	tp->ti_client = cdata;
 
@@ -701,6 +866,88 @@ enumerate:
     }
 }
 
+/*
+ * --------------------------------------------------------------------
+ *
+ * DBResetTilePlaneSpecial --
+ *
+ * This routine works like DBResetTilePlane(), but is designed
+ * specifically to be run after extFindNodes() or ExtFindRegions()
+ * to check for split tiles that have an allocated ExtSplitRegion
+ * structure in the ClientData;  this needs to be freed before
+ * resetting the ClientData value to "cdata".  It is not necessary
+ * to know anything about the ExtSplitRegion structure other than
+ * the condition under which it can be expected to be present,
+ * which is a split tile with neither side having type TT_SPACE.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	Resets the ti_client fields of all tiles.
+ *
+ * --------------------------------------------------------------------
+ */
+
+void
+DBResetTilePlaneSpecial(plane, cdata)
+    Plane *plane;	/* Plane whose tiles are to be reset */
+    ClientData cdata;
+{
+    Tile *tp, *tpnew;
+    const Rect *rect = &TiPlaneRect;
+
+    /* Start with the leftmost non-infinity tile in the plane */
+    tp = TR(plane->pl_left);
+
+    /* Each iteration visits another tile on the LHS of the search area */
+    while (TOP(tp) > rect->r_ybot)
+    {
+	/* Each iteration resets another tile */
+enumerate:
+	if (IsSplit(tp))
+	    if ((TiGetLeftType(tp) != TT_SPACE) && (TiGetRightType(tp) != TT_SPACE))
+		if (tp->ti_client != cdata)
+		{
+		    ASSERT(TiGetBody((Tile *)tp->ti_client) == CLIENTDEFAULT,
+				"DBResetTilePlaneSpecial");
+		    freeMagic(tp->ti_client);
+		}
+
+	tp->ti_client = cdata;
+
+	/* Move along to the next tile */
+	tpnew = TR(tp);
+	if (LEFT(tpnew) < rect->r_xtop)
+	{
+	    while (BOTTOM(tpnew) >= rect->r_ytop) tpnew = LB(tpnew);
+	    if (BOTTOM(tpnew) >= BOTTOM(tp) || BOTTOM(tp) <= rect->r_ybot)
+	    {
+		tp = tpnew;
+		goto enumerate;
+	    }
+	}
+
+	/* Each iteration returns one tile further to the left */
+	while (LEFT(tp) > rect->r_xbot)
+	{
+	    if (BOTTOM(tp) <= rect->r_ybot)
+		return;
+	    tpnew = LB(tp);
+	    tp = BL(tp);
+	    if (BOTTOM(tpnew) >= BOTTOM(tp) || BOTTOM(tp) <= rect->r_ybot)
+	    {
+		tp = tpnew;
+		goto enumerate;
+	    }
+	}
+
+	/* At left edge -- walk down to next tile along the left edge */
+	for (tp = LB(tp); RIGHT(tp) <= rect->r_xbot; tp = TR(tp))
+	    /* Nothing */;
+    }
+}
+
 /*
  * --------------------------------------------------------------------
  *
@@ -723,9 +970,7 @@ enumerate:
  *
  * This procedure uses a carfully constructed non-recursive area
  * enumeration algorithm.  Care is taken to not access a tile that has
- * been deallocated.  The only exception is for a tile that has just been
- * passed to free(), but no more calls to free() or malloc() have been made.
- * Magic's malloc allows this.
+ * been deallocated.
  *
  * --------------------------------------------------------------------
  */
@@ -735,11 +980,12 @@ DBFreePaintPlane(plane)
     Plane *plane;	/* Plane whose storage is to be freed */
 {
     Tile *tp, *tpnew;
-    Rect *rect = &TiPlaneRect;
+    const Rect *rect = &TiPlaneRect;
 
     /* Start with the bottom-right non-infinity tile in the plane */
     tp = BL(plane->pl_right);
 
+    Tile *delayed = NULL;
     /* Each iteration visits another tile on the RHS of the search area */
     while (BOTTOM(tp) < rect->r_ytop)
     {
@@ -762,9 +1008,9 @@ enumerate:
 	/* Each iteration returns one tile further to the right */
 	while (RIGHT(tp) < rect->r_xtop)
 	{
-	    TiFree(tp);
-	    tpnew = RT(tp);
-	    tp = TR(tp);
+	    TiFree1(&delayed, tp);
+	    tpnew = RT(tp); /* deref of delayed */
+	    tp = TR(tp); /* deref of delayed */
 	    if (CLIP_TOP(tpnew) <= CLIP_TOP(tp) && BOTTOM(tpnew) < rect->r_ytop)
 	    {
 		tp = tpnew;
@@ -772,13 +1018,14 @@ enumerate:
 	    }
 	}
 
-	TiFree(tp);
+	TiFree1(&delayed, tp);
 	/* At right edge -- walk up to next tile along the right edge */
-	tp = RT(tp);
+	tp = RT(tp); /* deref of delayed */
 	if (BOTTOM(tp) < rect->r_ytop) {
 	    while(LEFT(tp) >= rect->r_xtop) tp = BL(tp);
 	}
     }
+    TiFreeIf(delayed);
 }
 
 /*
@@ -918,8 +1165,9 @@ DBCheckMaxHStrips(plane, area, proc, cdata)
  */
 
 int
-dbCheckMaxHFunc(tile, dbc)
+dbCheckMaxHFunc(tile, dinfo, dbc)
     Tile *tile;
+    TileType dinfo;		/* (unused) */
     struct dbCheck *dbc;
 {
     Tile *tp;
@@ -1010,8 +1258,9 @@ DBCheckMaxVStrips(plane, area, proc, cdata)
  */
 
 int
-dbCheckMaxVFunc(tile, dbc)
+dbCheckMaxVFunc(tile, dinfo, dbc)
     Tile *tile;
+    TileType dinfo;		/* (unused) */
     struct dbCheck *dbc;
 {
     Tile *tp;

database/DBtimestmp.c

@@ -137,8 +137,10 @@ DBFixMismatch()
 
 	cellDef = mismatch->mm_cellDef;
 	oldArea = mismatch->mm_oldArea;
-	freeMagic((char *) mismatch);
+	free_magic1_t mm1 = freeMagic1_init();
+	freeMagic1(&mm1, (char *) mismatch);
 	mismatch = mismatch->mm_next;
+	freeMagic1_end(&mm1);
 	if (cellDef->cd_flags & CDPROCESSED) continue;
 
 	(void) DBCellRead(cellDef, TRUE, TRUE, NULL);
@@ -182,13 +184,15 @@ DBFixMismatch()
     }
     SigEnableInterrupts();
     TxPrintf("Timestamp mismatches found in these cells: ");
+    free_magic1_t mm1 = freeMagic1_init();
     while (cl != NULL)
     {
 	TxPrintf("%s", cl->cl_cell->cd_name);
 	if (cl->cl_next != NULL) TxPrintf(", ");
-	freeMagic(cl);
+	freeMagic1(&mm1, cl);
 	cl = cl->cl_next;
     }
+    freeMagic1_end(&mm1);
     TxPrintf(".\n");
     TxFlush();
     if (redisplay) WindAreaChanged((MagWindow *) NULL, (Rect *) NULL);
@@ -227,16 +231,18 @@ DBUpdateStamps(def)
 
     else if (def->cd_flags & CDGETNEWSTAMP)
     {
-	if (def->cd_flags & CDFIXEDSTAMP)
+	if (def->cd_flags & (CDNOEDIT | CDFIXEDSTAMP))
 	    def->cd_flags &= ~CDGETNEWSTAMP;
 	else
 	    dbStampFunc(def);
     }
 }
 
+/*ARGSUSED*/
 int
-dbStampFunc(cellDef)
+dbStampFunc(cellDef, cdata)
     CellDef *cellDef;
+    ClientData cdata;	/* UNUSED */
 {
     CellUse *cu;
     CellDef *cd;
@@ -247,6 +253,26 @@ dbStampFunc(cellDef)
 
     if (cellDef->cd_timestamp == timestamp) return 0;
 
+    /* Non-editable cells should not try to update timestamps, as the
+     * new timestamp cannot be written back to the file.  This is
+     * basically a hack solution for the problem that running DRC on
+     * all cells causes all cells, including non-editable ones, to be
+     * marked as modified, even if there were no DRC changes in the
+     * cell.  It is possible to get into trouble this way by modifying
+     * a cell and then marking it as non-editable
+     */
+
+    if (cellDef->cd_flags & CDNOEDIT)
+    {
+	cellDef->cd_flags &= ~CDGETNEWSTAMP;
+	return 0;
+    }
+
+    /*
+     * Do not force a non-edit cell or a cell with a fixed timestamp
+     * to update its timestamp, as it cannot or should not.  Just clear
+     * any flag suggesting that it needs a new timestamp.
+     */
     if (!(cellDef->cd_flags & CDFIXEDSTAMP))
 	cellDef->cd_timestamp = timestamp;
 

database/Makefile

@@ -15,6 +15,18 @@ SRCS     =  DBbound.c DBcell.c DBcellbox.c DBcellcopy.c \
 include ${MAGICDIR}/defs.mak
 
 LIB_OBJS += ${MAGICDIR}/tiles/libtiles.o ${MAGICDIR}/utils/libutils.o
-CLEANS += database.h
+# database.h is managed by the toplevel Makefile, because it has a build dependency
+# order affecting multiple modules that need it.   Both the creation time and the
+# removal time (during 'clean') are managed by toplevel Makefile.
+# if it was additionally removed by this clause here, it only causes bogus errors
+# to be seen during some make operations due to race conditions caused by the
+# unexpected removal by this clause in parallel MAKE execution of other modules
+# that thought the file existed.  FWIW database.h should be created first (near the
+# start of top level build) and removed last (near the end of a top level clean).
+#CLEANS += database.h
+
+# This is delegated back to the top level Makefile
+database.h: ${MAGICDIR}/database/database.h.in
+	${MAKE} -C ${MAGICDIR} database/database.h
 
 include ${MAGICDIR}/rules.mak

database/arrayinfo.h

@@ -0,0 +1,62 @@
+/*
+ * arrayinfo.h --
+ *
+ *     *********************************************************************
+ *     * Copyright (C) 1985, 1990 Regents of the University of California. *
+ *     * Permission to use, copy, modify, and distribute this              *
+ *     * software and its documentation for any purpose and without        *
+ *     * fee is hereby granted, provided that the above copyright          *
+ *     * notice appear in all copies.  The University of California        *
+ *     * makes no representations about the suitability of this            *
+ *     * software for any purpose.  It is provided "as is" without         *
+ *     * express or implied warranty.  Export of this software outside     *
+ *     * of the United States of America may require an export license.    *
+ *     *********************************************************************
+ *
+ */
+
+#ifndef _MAGIC__DATABASE__ARRAYINFO_H
+#define _MAGIC__DATABASE__ARRAYINFO_H
+
+/*
+ * Description of an array.
+ * The bounds xlo .. xhi and ylo .. yhi are transformed versions
+ * of the bounds xlo' .. xhi' and ylo' .. yhi' supplied by the
+ * user:
+ *
+ * User supplies:
+ *	xlo'	index of leftmost array element in root coordinates
+ *	xhi'	index of rightmost array element in root coordinates
+ *	ylo'	index of bottommost array element in root coordinates
+ *	yhi'	index of topmost array element in root coordinates
+ *
+ * There is no constraint on the order of any of these indices; xlo' may
+ * be less than, equal to, or greater than xhi', and similarly for ylo'
+ * and yhi'.
+ *
+ * In addition, the separations xsep and ysep are transformed versions
+ * of the separations xsep' and ysep' supplied by the user:
+ *
+ * User supplies:
+ *	xsep'	(positive) X spacing between array elements in root coords
+ *	ysep'	(positive) Y spacing between array elements in root coords
+ *
+ * When the array is made via DBMakeArray, both the indices and the spacings
+ * are transformed down to the coordinates of the CellDef that is the child
+ * of the use containing the ArrayInfo.
+ *
+ * The significance of the various values is as follows:  the [xlo, ylo]
+ * element of the array is gotten by transforming the celldef by the
+ * transformation in the celluse.  the [x, y] element is gotten by
+ * transforming the celldef by xsep*abs(x-xlo) in x, ysep*abs(y-ylo) in
+ * y, and then transforming by the transformation in the celluse.
+ */
+
+typedef struct
+{
+    int		ar_xlo, ar_xhi;		/* Inclusive low/high X bounds */
+    int		ar_ylo, ar_yhi;		/* Inclusive low/high Y bounds */
+    int		ar_xsep, ar_ysep;	/* X,Y sep between array elements */
+} ArrayInfo;
+
+#endif /* _MAGIC__DATABASE__ARRAYINFO_H */

database/database.h.in

@@ -22,24 +22,24 @@
  * rcsid "$Header: /usr/cvsroot/magic-8.0/database/database.h.in,v 1.8 2010/08/25 17:33:55 tim Exp $"
  */
 
-#ifndef _DATABASE_H
-#define	_DATABASE_H
+#ifndef _MAGIC__DATABASE__DATABASE_H
+#define _MAGIC__DATABASE__DATABASE_H
 
-#ifndef	_TILES_H
+#ifndef _MAGIC__TILES__TILE_H
 #include "tiles/tile.h"
-#endif	/* _TILES_H */
+#endif
 
-#ifndef	_HASH_H
+#ifndef _MAGIC__UTILS__HASH_H
 #include "utils/hash.h"
-#endif	/* _HASH_H */
+#endif
 
-#ifndef	_STACK_H
+#ifndef _MAGIC__UTILS__STACK_H
 #include "utils/stack.h"
-#endif	/* _STACK_H */
+#endif
 
-#ifndef _BPLANE_H
+#ifndef _MAGIC__BPLANE__BPLANE_H
 #include "bplane/bplane.h"
-#endif /* _BPLANE_H */
+#endif
 
 /* ----------------------- Tunable constants -------------------------- */
 
@@ -303,9 +303,14 @@ typedef struct label
 #define PORT_SHAPE_RING	   0x1000	/* Port is a ring shape		*/
 #define PORT_SHAPE_THRU	   0x1800	/* Port is a feedthrough shape	*/
 
-#define PORT_VISITED	   0x2000	/* Bit for checking if a port	*/
+#define LABEL_STICKY	   0x2000	/* Label does not change layers	*/
+#define LABEL_UNIQUE	   0x4000	/* Temporary unique label	*/
+
+/* The last two flags are never used at the same time and so can share
+ * a flag bit.
+ */
+#define PORT_VISITED	   0x8000	/* Bit for checking if a port	*/
 					/* has been previously visited.	*/
-#define LABEL_STICKY	   0x4000	/* Label does not change layers	*/
 #define LABEL_GENERATE	   0x8000	/* Auto-generated label		*/
 
 /*
@@ -403,6 +408,9 @@ typedef struct celldef
  *	    is added to the magic database.  The flag is used to identify
  *	    whether the cell has been processed when forcing the GDS
  *	    stream data to be read in post-order.
+ *	CDPRELOADED is similar to CDPROCESSEDGDS but is used in cases
+ *	    other than forced post-order reading, such as flattening
+ *	    or flatten-by-name.
  *	CDVENDORGDS indicates that the cell was read from a GDS stream
  *	    with the option "gds readonly true".
  *	CDVISITED indicates that at least one instance of the cell was
@@ -434,53 +442,15 @@ typedef struct celldef
 #define CDFLATGDS	 0x00400
 #define CDFLATTENED	 0x00800
 #define CDPROCESSEDGDS	 0x01000
-#define CDVENDORGDS	 0x02000
-#define CDVISITED	 0x04000
-#define CDDEREFERENCE	 0x08000
-#define CDFIXEDSTAMP	 0x10000
-#define CDNOEXTRACT	 0x20000
-#define CDDONTUSE	 0x40000
+#define CDPRELOADED	 0x02000
+#define CDVENDORGDS	 0x04000
+#define CDVISITED	 0x08000
+#define CDDEREFERENCE	 0x10000
+#define CDFIXEDSTAMP	 0x20000
+#define CDNOEXTRACT	 0x40000
+#define CDDONTUSE	 0x80000
 
-/*
- * Description of an array.
- * The bounds xlo .. xhi and ylo .. yhi are transformed versions
- * of the bounds xlo' .. xhi' and ylo' .. yhi' supplied by the
- * user:
- *
- * User supplies:
- *	xlo'	index of leftmost array element in root coordinates
- *	xhi'	index of rightmost array element in root coordinates
- *	ylo'	index of bottommost array element in root coordinates
- *	yhi'	index of topmost array element in root coordinates
- *
- * There is no constraint on the order of any of these indices; xlo' may
- * be less than, equal to, or greater than xhi', and similarly for ylo'
- * and yhi'.
- *
- * In addition, the separations xsep and ysep are transformed versions
- * of the separations xsep' and ysep' supplied by the user:
- *
- * User supplies:
- *	xsep'	(positive) X spacing between array elements in root coords
- *	ysep'	(positive) Y spacing between array elements in root coords
- *
- * When the array is made via DBMakeArray, both the indices and the spacings
- * are transformed down to the coordinates of the CellDef that is the child
- * of the use containing the ArrayInfo.
- *
- * The significance of the various values is as follows:  the [xlo, ylo]	
- * element of the array is gotten by transforming the celldef by the
- * transformation in the celluse.  the [x, y] element is gotten by
- * transforming the celldef by xsep*abs(x-xlo) in x, ysep*abs(y-ylo) in
- * y, and then transforming by the transformation in the celluse.
- */
-
-typedef struct
-{
-    int		ar_xlo, ar_xhi;		/* Inclusive low/high X bounds */
-    int		ar_ylo, ar_yhi;		/* Inclusive low/high Y bounds */
-    int		ar_xsep, ar_ysep;	/* X,Y sep between array elements */
-} ArrayInfo;
+#include "database/arrayinfo.h" /* ArrayInfo */
 
 /*
  * Since a cell may be used in an orientation different from that
@@ -586,6 +556,18 @@ typedef struct diag_info
    bool side;
 } DiagInfo;
 
+/* Where search functions need to return a Tile pointer and tile split	*/
+/* information, use this structure.  Contains a pointer to its own	*/
+/* structure type so that it may also be used to create a linked list	*/
+/* of tiles including split side information.				*/
+
+typedef struct tile_and_dinfo
+{
+    struct tile_and_dinfo *tad_next;
+    Tile     *tad_tile;
+    TileType  tad_dinfo;
+} TileAndDinfo;
+
 /* This would normally go in geometry.h except that it uses TileType.	*/
 /* Used in selOps.c but also passed back to CmdRS.c for select command.	*/
 
@@ -596,6 +578,20 @@ typedef struct extRectList
    struct extRectList *r_next;
 } ExtRectList;
 
+/* Structure similar to the above, but adding a pointer to a cell use ID
+ * and a client data record which can be used to hold a region pointer.
+ */
+
+typedef struct extConnList
+{
+   char *r_useid;		/* Cell Use being connected to */
+   TileType r_type;		/* Connecting tile type in the parent */
+   Rect r_r;			/* Area of connection */
+   ClientData r_upnode;		/* Parent node making the connection */
+   ClientData r_downnode;	/* Child node making the connection */
+   struct extConnList *r_next;	/* Next item in the linked list */
+} ExtConnList;
+
 /* -------------------- Search context information -------------------- */
 
 /* Search contexts are used in hierarchical searches */
@@ -647,7 +643,7 @@ typedef struct treeFilter
 {
     int (*tf_func)();		/* Client's filter function */
     ClientData tf_arg;		/* Client's argument to pass to filter */
-    TileTypeBitMask *tf_mask;	/* Only process tiles with these types */
+    const TileTypeBitMask *tf_mask;	/* Only process tiles with these types */
     int tf_xmask;		/* Expand mask */
     PlaneMask tf_planes;	/* Mask of planes which will be visited */
     TileType tf_dinfo;		/* Info for processing triangular areas */
@@ -669,6 +665,7 @@ typedef struct treeFilter
 #define TF_LABEL_ATTACH_NOT_SE	0x10	/* Same as above, ignore tile SE corner */
 #define TF_LABEL_ATTACH_NOT_SW	0x20	/* Same as above, ignore tile SW corner */
 #define TF_LABEL_ATTACH_CORNER	0x3C	/* Mask of the four types above */
+#define TF_LABEL_REVERSE_SEARCH 0x40	/* Search children before parent */
 
 /* To do:  Make the tpath entries dynamically allocated */
 #define FLATTERMSIZE 4096		/* Used for generating flattened labels */
@@ -685,7 +682,7 @@ struct conSrArg
 {
     CellDef *csa_def;                   /* Definition being searched. */
     int csa_pNum;			/* Index of plane being searched */
-    TileTypeBitMask *csa_connect;       /* Table indicating what connects
+    const TileTypeBitMask *csa_connect; /* Table indicating what connects
                                          * to what.
                                          */
     int (*csa_clientFunc)();            /* Client function to call. */
@@ -700,19 +697,19 @@ struct conSrArg
 typedef struct
 {
     Rect                area;           /* Area to process */
-    TileTypeBitMask     *connectMask;   /* Connection mask for search */
+    const TileTypeBitMask *connectMask; /* Connection mask for search */
     TileType            dinfo;          /* Info about triangular search areas */
 } conSrArea;
 
 struct conSrArg2
 {
     CellUse             *csa2_use;      /* Destination use */
-    TileTypeBitMask     *csa2_connect;  /* Table indicating what connects
+    const TileTypeBitMask *csa2_connect;/* Table indicating what connects
                                          * to what.
                                          */
     SearchContext       *csa2_topscx;   /* Original top-level search context */
     int                  csa2_xMask;    /* Cell window mask for search */
-    Rect                *csa2_bounds;   /* Area that limits the search */
+    const Rect          *csa2_bounds;   /* Area that limits the search */
 
     Stack               *csa2_stack;    /* Stack of full csa2_list entries */
     conSrArea           *csa2_list;     /* List of areas to process */
@@ -722,6 +719,25 @@ struct conSrArg2
 
 #define CSA2_LIST_SIZE 65536            /* Number of entries per list */
 
+/* ------------------------  Properties  ------------------------------ */
+
+/* Note that the property record is a single allocated block large enough
+ * to hold the string or integer list, and can be freed as a single block.
+ * The array bounds, like those of lab_text for labels, are placeholders.
+ */
+
+typedef struct
+{
+    int		prop_type;	/* See codes below; e.g., PROPERTY_TYPE_STRING */
+    int		prop_len;	/* String length or number of values */
+    union {
+	char  prop_string[8];	/* For PROPERTY_TYPE_STRING */
+	int   prop_integer[2];	/* For PROPERTY_TYPE_INTEGER or _DIMENSION */
+	dlong prop_double[1];	/* For PROPERTY_TYPE_DOUBLE */
+	Plane *prop_plane;	/* For PROPERTY_TYPE_PLANE */
+    } prop_value;
+} PropertyRecord;
+
 /* -------------- Undo information passed to DBPaintPlane ------------- */
 
 typedef struct
@@ -754,6 +770,14 @@ typedef struct
 #define PAINT_MARK	1	/* Mark tiles that are painted */
 #define PAINT_XOR	2	/* Use with XOR function to prevent double-painting */
 
+/* ---------------------- Codes for properties -------------------------*/
+
+#define PROPERTY_TYPE_STRING	0	/* ASCII string property */
+#define PROPERTY_TYPE_INTEGER	1	/* Fixed integer property */
+#define PROPERTY_TYPE_DIMENSION	2	/* Integer property that scales with units */
+#define PROPERTY_TYPE_DOUBLE	3	/* Double-long integer (for file positions) */
+#define PROPERTY_TYPE_PLANE	4	/* A tile plane structure */
+
 /* -------------------- Exported procedure headers -------------------- */
 
     /* Painting/erasing */
@@ -808,7 +832,7 @@ extern void DBTechInit();
 extern bool DBTechSetTech();
 extern void DBTechInitVersion();
 extern bool DBTechSetVersion();
-extern bool DBTechAddPlane();
+extern bool DBTechAddPlane(const char *sectionName, int argc, char *argv[]);
 extern bool DBTechAddType();
 extern bool DBTechAddAlias();
 extern void DBTechFinalType();
@@ -820,7 +844,7 @@ extern int DBTechNamePlane(), DBTechNoisyNamePlane();
 extern PlaneMask DBTechNameMask(), DBTechNoisyNameMask();
 extern PlaneMask DBTechTypesToPlanes();
 extern bool DBTechTypesOnPlane();
-extern void DBTechInitPlane();
+extern void DBTechInitPlane(void);
 extern void DBTypeInit();
 extern void DBTechInitType();
 extern void DBTechInitCompose();
@@ -879,7 +903,7 @@ extern void DBSetTrans();
 extern void DBArrayOverlap();
 extern void DBComputeArrayArea();
 extern Transform *DBGetArrayTransform();
-extern char *DBPrintUseId();
+extern char *DBPrintUseId(SearchContext *scx, char *name, int size, bool display_only);
 
     /* Massive copying */
 extern void DBCellCopyPaint();
@@ -939,7 +963,9 @@ extern void DBFreePaintPlane();
 
     /* Cell properties */
 extern void DBPropPut();
-extern ClientData DBPropGet();
+extern PropertyRecord *DBPropGet();
+extern char *DBPropGetString();
+extern dlong DBPropGetDouble();
 extern int DBPropEnum();
 extern void DBPropClearAll();
 
@@ -955,6 +981,10 @@ extern int DBArraySr();
 extern bool DBNearestLabel();
 extern int DBSrLabelLoc();
 extern TileType DBTransformDiagonal();
+extern bool DBTestNMInteract(Rect *rect1, TileType tt1, Tile *t2, TileType di2, bool overlap_only);
+extern int dbcUnconnectFunc(Tile *tile, TileType dinfo, ClientData clientData); /* (notused) */
+extern int dbSrConnectFunc(Tile *tile, TileType dinfo, ClientData clientData); /*  (struct conSrArg *csa) */
+extern int dbSrConnectStartFunc(Tile *tile, TileType dinfo, ClientData clientData); /* cb_database_srpaintarea_t (Tile **pTile) */
 
 /* C99 compat */
 extern void DBEraseValid();
@@ -970,7 +1000,7 @@ extern void DBUndoPutLabel();
 extern bool DBCellRename();
 extern bool DBCellDelete();
 extern int  DBCellSrArea();
-extern int  DBSrCellPlaneArea();
+extern int  DBSrCellPlaneArea(BPlane *plane, const Rect *rect, int (*func)(), ClientData arg);
 extern int  DBMoveCell();
 extern bool DBReLinkCell();
 extern int  DBBoundCellPlane();
@@ -983,6 +1013,7 @@ extern int  DBScaleCell();
 extern TileType DBTechNameTypes();
 extern void DBTreeFindUse();
 extern void DBGenerateUniqueIds();
+extern void DBSelectionUniqueIds();
 extern TileType DBInvTransformDiagonal();
 extern bool DBIsSubcircuit();
 extern int  DBSrPaintNMArea();
@@ -1000,10 +1031,10 @@ extern int  dbIsPrimary();
 extern void dbTechMatchResidues();
 extern void DBUndoInit();
 extern void DBResetTilePlane();
+extern void DBResetTilePlaneSpecial();
 extern void DBNewYank();
 extern int  DBSrPaintClient();
 extern int  DBSrConnect();
-extern int  DBSrConnectOnePlane();
 extern char *dbFgets();
 extern void DBAdjustLabelsNew();
 extern bool DBScaleValue();
@@ -1032,6 +1063,7 @@ extern int DBLambda[2];
 /* -------------------- Exported magic file suffix -------------------- */
 
 extern char *DBSuffix;		/* Suffix appended to all Magic cell names */
+extern bool DBPropCompat;	/* Backwards-compatible properties */
 
 /* -------------------- User Interface Stuff -------------------------- */
 
@@ -1044,6 +1076,19 @@ extern unsigned char DBVerbose;	/* If 0, don't print any messages	*/
 #define DB_VERBOSE_WARN	2
 #define DB_VERBOSE_ALL	3
 
+/* ---------- Definitions for expanding/unexpanding cells --------------*/
+
+/* Selection expansion flags */
+#define DB_EXPAND_MASK	 	3	/* 1 = expand, 0 = unexpand, 2 = toggle */
+#define DB_EXPAND_SURROUND_MASK	4	/* 1 = surround, 0 = touch */
+
+/* Selection expansion values */
+#define DB_EXPAND      	   0
+#define DB_UNEXPAND        1
+#define DB_EXPAND_TOGGLE   2
+#define DB_EXPAND_SURROUND 4
+#define DB_EXPAND_OVERLAP  0
+
 /* ------------------ Exported technology variables ------------------- */
 
 /***
@@ -1090,10 +1135,10 @@ extern int DBNumPlanes;
 extern HashTable	DBTypeAliasTable;
 
     /* Gives the official long name of each plane: */
-extern char		*DBPlaneLongNameTbl[NP];
+extern const char	*DBPlaneLongNameTbl[NP];
 
     /* Gives a short name for each plane: */
-extern char		*DBPlaneShortName();
+extern const char	*DBPlaneShortName();
 
     /* Gives for each plane a mask of all tile types stored in that plane: */
 extern TileTypeBitMask	DBPlaneTypes[NP];
@@ -1152,10 +1197,10 @@ extern int		DBTypePlaneTbl[TT_MAXTYPES];
 extern PlaneMask	DBTypePlaneMaskTbl[TT_MAXTYPES];
 
     /* Gives the long name for each tile type: */
-extern char		*DBTypeLongNameTbl[TT_MAXTYPES];
+extern const char	*DBTypeLongNameTbl[TT_MAXTYPES];
 
     /* Gives a short name for a tile type: */
-extern char		*DBTypeShortName();
+extern const char	*DBTypeShortName(TileType type);
 
     /*
      * The following give masks of all planes that may be affected

database/databaseInt.h

@@ -20,8 +20,8 @@
  * rcsid $Header: /usr/cvsroot/magic-8.0/database/databaseInt.h,v 1.3 2010/06/24 12:37:15 tim Exp $
  */
 
-#ifndef _DATABASEINT_H
-#define _DATABASEINT_H
+#ifndef _MAGIC__DATABASE__DATABASEINT_H
+#define _MAGIC__DATABASE__DATABASEINT_H
 
 #include "database/database.h"
 
@@ -194,6 +194,8 @@ typedef struct
 extern int dbNumSavedRules;
 extern Rule dbSavedRules[];
 
+extern HashTable dbCellDefTable;	/* Exported for diagnostics */
+
 /* -------------------- Internal procedure headers -------------------- */
 
 extern void DBUndoPutLabel();
@@ -247,4 +249,4 @@ extern TileTypeBitMask dbNotDefaultPaintTbl[];
 #define	ERASEAFFECTS(t, s) \
 	((t) != TT_SPACE && DBStdEraseEntry((t), (s), DBPlane(t)) != (t))
 
-#endif /* _DATABASEINT_H */
+#endif /* _MAGIC__DATABASE__DATABASEINT_H */

database/fonts.h

@@ -10,12 +10,12 @@
  * rcsid "$$"
  */
 
-#ifndef _FONTS_H
-#define	_FONTS_H
+#ifndef _MAGIC__DATABASE__FONTS_H
+#define _MAGIC__DATABASE__FONTS_H
 
-#ifndef	_TILES_H
+#ifndef _MAGIC__TILES__TILE_H
 #include "tiles/tile.h"
-#endif	/* _TILES_H */
+#endif
 
 /* ---------------------------- Fonts --------------------------------- */
 
@@ -39,4 +39,4 @@ typedef struct
 extern MagicFont **DBFontList;	/* List of loaded font vectors	*/
 extern int DBNumFonts;		/* Number of loaded fonts	*/
 
-#endif /* _FONTS_H */
+#endif /* _MAGIC__DATABASE__FONTS_H */

dbwind/DBWbuttons.c

@@ -27,6 +27,7 @@ static char rcsid[] __attribute__ ((unused)) = "$Header: /usr/cvsroot/magic-8.0/
 #include <stdio.h>
 #include <string.h>
 
+#include "tcltk/tclmagic.h"
 #include "utils/magic.h"
 #include "utils/geometry.h"
 #include "tiles/tile.h"
@@ -58,7 +59,7 @@ static char *dbwButtonDoc[MAXBUTTONHANDLERS];
 			/* A documentation string for each handler:  tells
 			 * what the button pushes and releases mean.
 			 */
-static void (*dbwButtonProcs[MAXBUTTONHANDLERS])();
+static cb_database_buttonhandler_t dbwButtonProcs[MAXBUTTONHANDLERS];
 			/* A procedure for each handler that is invoked
 			 * on button presses and releases when that handler
 			 * is the current one.
@@ -68,7 +69,7 @@ static int dbwButtonCursors[MAXBUTTONHANDLERS];
 
 static int dbwButtonCurrentIndex;
 			/* Index of current handler. */
-void (*DBWButtonCurrentProc)();
+cb_database_buttonhandler_t DBWButtonCurrentProc;
 			/* Current button-handling procedure. */
 
 static int buttonCorner = TOOL_ILG;	/* Nearest corner when button went
@@ -108,18 +109,19 @@ static int buttonCorner = TOOL_ILG;	/* Nearest corner when button went
  */
 
 void
-DBWAddButtonHandler(name, proc, cursor, doc)
-    char *name;			/* Name of this button handler.  This name
+DBWAddButtonHandler(
+    const char *name,		/* Name of this button handler.  This name
 				 * is what's passed to DBWChangeButtonHandler
 				 * to activate the handler.
 				 */
-    void (*proc)();		/* Procedure to call on button actions when
+    const cb_database_buttonhandler_t proc,
+				/* Procedure to call on button actions when
 				 * this handler is active.
 				 */
-    int cursor;			/* Cursor shape (e.g. STYLE_CURS_NORMAL) to
+    int cursor,			/* Cursor shape (e.g. STYLE_CURS_NORMAL) to
 				 * use when this handler is active.
 				 */
-    char *doc;			/* A documentation string for this handler:
+    const char *doc)		/* A documentation string for this handler:
 				 * describes what the button pushes do when
 				 * this handler is active.
 				 */
@@ -129,8 +131,11 @@ DBWAddButtonHandler(name, proc, cursor, doc)
     for (i = 0; i < MAXBUTTONHANDLERS; i++)
     {
 	if (dbwButtonHandlers[i] != NULL) continue;
-	(void) StrDup(&dbwButtonHandlers[i], name);
-	(void) StrDup(&dbwButtonDoc[i], doc);
+	StrDup(&dbwButtonHandlers[i], name);
+	if (doc != NULL)
+	    StrDup(&dbwButtonDoc[i], doc);
+	else
+	    dbwButtonDoc[i] = (char *)NULL;
 	dbwButtonProcs[i] = proc;
 	dbwButtonCursors[i] = cursor;
 	return;
@@ -239,6 +244,69 @@ DBWChangeButtonHandler(name)
     return oldName;
 }
 
+/*
+ * ----------------------------------------------------------------------------
+ *
+ * DBWGetButtonHandler --
+ *
+ *	Return the name of the current button handler.  This does the same
+ *	thing as DBWChangeButtonHandler(name) with an invalid name, but
+ *	without printing the error messages.  However, if magic is running
+ *	with the Tcl interpreter wrapper, then return the string value of
+ *	$Opts(tool), if it exists.
+ *
+ * Results:
+ *	A pointer to the name of the current button handler.
+ *
+ * Side effects:
+ *	None.	
+ *
+ * ----------------------------------------------------------------------------
+ */
+
+char *
+DBWGetButtonHandler()
+{
+#ifdef MAGIC_WRAPPER
+    char *toolName;
+    toolName = (char *)Tcl_GetVar2(magicinterp, "Opts", "tool", TCL_GLOBAL_ONLY);
+    if (toolName != NULL) return toolName;
+#endif
+    
+    return dbwButtonHandlers[dbwButtonCurrentIndex];
+}
+
+/*
+ * ----------------------------------------------------------------------------
+ *
+ * DBWButtonHandlerIndex()
+ *
+ *	Given a string, return the index of the button handler.  If the
+ *	string does not correspond to any button handler name, then
+ *	return -1.
+ *
+ * Results:
+ *	Index of button handler, if it exists;  -1 otherwise.
+ *
+ * Side effects:
+ *	None.
+ *
+ * ----------------------------------------------------------------------------
+ */
+
+int
+DBWButtonHandlerIndex(char *toolName)
+{
+    int i;
+
+    for (i = 0; i < MAXBUTTONHANDLERS; i++)
+    {
+	if (dbwButtonHandlers[i] == NULL) return -1;
+	else if (!strcmp(toolName, dbwButtonHandlers[i])) return i;
+    }
+    return -1;
+}
+
 /*
  * ----------------------------------------------------------------------------
  *
@@ -260,7 +328,10 @@ DBWChangeButtonHandler(name)
 void
 DBWPrintButtonDoc()
 {
-    TxPrintf("%s", dbwButtonDoc[dbwButtonCurrentIndex]);
+    if (dbwButtonDoc[dbwButtonCurrentIndex])
+	TxPrintf("%s", dbwButtonDoc[dbwButtonCurrentIndex]);
+    else
+	TxPrintf("(no usage information)\n");
 }
 
 

dbwind/DBWcommands.c

@@ -38,7 +38,7 @@ static char rcsid[] __attribute__ ((unused)) = "$Header: /usr/cvsroot/magic-8.0/
  * Standard DBWind command set
  */
 
-extern void CmdAddPath(), CmdAntennaCheck(), CmdArray();
+extern void CmdAddPath(), CmdAntennaCheck(), CmdArchive(), CmdArray();
 extern void CmdBox(), CmdCellname(), CmdClockwise();
 extern void CmdContact(), CmdCopy(), CmdCorner();
 extern void CmdCrash(), CmdCrosshair();
@@ -54,7 +54,7 @@ extern void CmdRandom(), CmdSave(), CmdScaleGrid(), CmdSee();
 extern void CmdSelect(), CmdSetLabel(), CmdSideways();
 extern void CmdShell(), CmdSnap();
 extern void CmdStretch(), CmdStraighten();
-extern void CmdTech(), CmdTool(), CmdUnexpand();
+extern void CmdTech(), CmdTool(), CmdUnexpand(), CmdUnits();
 extern void CmdUpsidedown(), CmdWhat(), CmdWire(), CmdWriteall();
 extern void CmdGoto(), CmdFlatten(), CmdXload(), CmdXor();
 
@@ -75,6 +75,7 @@ extern void CmdExtResis();
 extern void CmdPsearch();
 extern void CmdPlowTest();
 extern void CmdShowtech();
+extern void CmdShowmem();
 extern void CmdTilestats();
 extern void CmdTsearch();
 extern void CmdWatch();
@@ -148,6 +149,9 @@ extern void CmdAutoExtToSpice();
 #else
 extern void CmdExtToSpice();
 #endif
+#else  /* !MAGIC_WRAPPER */
+extern void CmdExtToSim();
+extern void CmdExtToSpice();
 #endif
 
 /*
@@ -208,6 +212,9 @@ DBWInitCommands()
     WindAddCommand(DBWclientID,
 	"*psearch plane count	invoke point search over box area",
 	CmdPsearch, FALSE);
+    WindAddCommand(DBWclientID,
+	"*showmem [file]	print internal memory usage",
+	CmdShowmem, FALSE);
     WindAddCommand(DBWclientID,
 	"*showtech [file]	print internal technology tables",
 	CmdShowtech, FALSE);
@@ -223,9 +230,15 @@ DBWInitCommands()
     WindAddCommand(DBWclientID,
 	"addpath [path]		append to current search path",
 	CmdAddPath, FALSE);
+#ifdef LEF_MODULE
     WindAddCommand(DBWclientID,
 	"antennacheck [path]	check for antenna violations",
 	CmdAntennaCheck, FALSE);
+#endif
+    WindAddCommand(DBWclientID,
+	"archive write|read file\n"
+	"			write or read the archive file \"file\".",
+	CmdArchive, FALSE);
     WindAddCommand(DBWclientID,
 	"array xsize ysize	OR\n"
 	"array xlo xhi ylo yhi\n"
@@ -464,6 +477,9 @@ DBWInitCommands()
     WindAddCommand(DBWclientID,
 	"unexpand		unexpand subcells under box",
 	CmdUnexpand, FALSE);
+    WindAddCommand(DBWclientID,
+	"units [type]		set type of units parsed and displayed",
+	CmdUnits, FALSE);
     WindAddCommand(DBWclientID,
 	"upsidedown		flip selection and box upside down",
 	CmdUpsidedown, FALSE);
@@ -555,8 +571,26 @@ DBWInitCommands()
 	"ext2spice [args]	convert extracted file(s) to a SPICE format file;"
 	" type\n\t\t\t\"ext2spice help\" for information on options",
 	CmdExtToSpice, FALSE);
-#endif	/* EXT2SPICE_AUTO */
-#endif  /* MAGIC_WRAPPER */
+#endif /* EXT2SPICE_AUTO */
+#else  /* !MAGIC_WRAPPER */
+    /* In non-Tcl builds (e.g. WASM), register the C implementations directly */
+    WindAddCommand(DBWclientID,
+	"exttosim [args]	convert extracted file(s) to a sim format file;"
+	" type\n\t\t\t\"exttosim help\" for information on options",
+	CmdExtToSim, FALSE);
+    WindAddCommand(DBWclientID,
+	"ext2sim [args]	convert extracted file(s) to a sim format file;"
+	" type\n\t\t\t\"ext2sim help\" for information on options",
+	CmdExtToSim, FALSE);
+    WindAddCommand(DBWclientID,
+	"exttospice [args]	convert extracted file(s) to a SPICE format file;"
+	" type\n\t\t\t\"exttospice help\" for information on options",
+	CmdExtToSpice, FALSE);
+    WindAddCommand(DBWclientID,
+	"ext2spice [args]	convert extracted file(s) to a SPICE format file;"
+	" type\n\t\t\t\"ext2spice help\" for information on options",
+	CmdExtToSpice, FALSE);
+#endif /* MAGIC_WRAPPER */
 
 
 #ifdef USE_READLINE

dbwind/DBWdisplay.c

@@ -421,7 +421,8 @@ DBWredisplay(w, rootArea, clipArea)
         /* Set style information beforehand */
         GrSetStuff(STYLE_LABEL);
 	(void) DBTreeSrLabels(&scontext, &DBAllTypeBits, bitMask,
-		(TerminalPath *) NULL, TF_LABEL_DISPLAY | TF_LABEL_ATTACH,
+		(TerminalPath *) NULL,
+		TF_LABEL_DISPLAY | TF_LABEL_ATTACH | TF_LABEL_REVERSE_SEARCH,
 		dbwLabelFunc, (ClientData)(&crec->dbw_visibleLayers));
 	GrClipTo(&rootClip);
     }
@@ -571,8 +572,9 @@ DBWredisplay(w, rootArea, clipArea)
  */
 
 int
-dbwPaintFunc(tile, cxp)
-    Tile *tile;	/* Tile to be redisplayed. */
+dbwPaintFunc(tile, dinfo, cxp)
+    Tile *tile;			/* Tile to be redisplayed. */
+    TileType dinfo;		/* Split tile information */
     TreeContext *cxp;		/* From DBTreeSrTiles */
 {
     SearchContext *scx = cxp->tc_scx;
@@ -652,7 +654,7 @@ dbwPaintFunc(tile, cxp)
     /* whether to render the outline with a fast rectangle-	*/
     /* drawing routine or to render it segment by segment.	*/
 
-    GrBox(dbwWindow, &scx->scx_trans, tile);
+    GrBox(dbwWindow, &scx->scx_trans, tile, dinfo);
     return 0;
 }
 
@@ -1075,8 +1077,10 @@ dbwBBoxFunc(scx)
  */
 
 int
-dbwTileFunc(tile)
+dbwTileFunc(tile, dinfo, clientdata)
     Tile *tile;				/* A tile to be redisplayed. */
+    TileType dinfo;			/* Split tile information (unused) */
+    ClientData clientdata;		/* (unused) */
 {
     Rect r, r2;
     int xoffset, yoffset;
@@ -1113,7 +1117,7 @@ dbwTileFunc(tile)
 
     if (dbwSeeTypes)
     {
-    	 (void) sprintf(string, "%s",DBTypeShortName(TiGetType(tile)));
+    	 (void) sprintf(string, "%s", DBTypeShortName(TiGetType(tile)));
     }
     else
     {
@@ -1129,7 +1133,7 @@ dbwTileFunc(tile)
 
 #define	XYOFFSET	12
 
-    for (i=0;  i<4;  i++)
+    for (i = 0; i < 4; i++)
     {
 	xoffset = 0;
 	yoffset = 0;
@@ -1172,13 +1176,13 @@ dbwTileFunc(tile)
 	    yoffset = temp;
 	}
 
-	if ( (dbwWatchTrans.t_a < 0) || (dbwWatchTrans.t_b < 0) )
+	if ((dbwWatchTrans.t_a < 0) || (dbwWatchTrans.t_b < 0))
 	{
 	    /* mirror in x */
 	    xoffset = -xoffset;
 	}
 
-	if ( (dbwWatchTrans.t_d < 0) || (dbwWatchTrans.t_e < 0) )
+	if ((dbwWatchTrans.t_d < 0) || (dbwWatchTrans.t_e < 0))
 	{
 	    /* mirror in y */
 	    yoffset = -yoffset;

dbwind/DBWelement.c

@@ -588,10 +588,12 @@ DBWElementDelete(MagWindow *w, char *name)
     if (elem->flags & DBW_ELEMENT_PERSISTENT)
 	elem->rootDef->cd_flags |= CDMODIFIED;
 
+    free_magic1_t mm1 = freeMagic1_init();
     for (stylePtr = elem->stylelist; stylePtr != NULL; stylePtr = stylePtr->next)
     {
-	freeMagic(stylePtr);
+	freeMagic1(&mm1, stylePtr);
     }
+    freeMagic1_end(&mm1);
     if (elem->type == ELEMENT_TEXT)
 	freeMagic(elem->text);
 
@@ -865,8 +867,11 @@ dbwelemGetTransform(use, transform, cdarg)
     return 1;
 }
 
+/*ARGSUSED*/
 int
-dbwElementAlways1()
+dbwElementAlways1(w, clientData)
+    MagWindow *w;		/* UNUSED */
+    ClientData clientData;	/* UNUSED */
 {
     return 1;
 }
@@ -1156,8 +1161,10 @@ DBWElementStyle(MagWindow *w, char *ename, int style, bool add)
 			(elem->stylelist->style == style))
 	    {
 		dbwElementUndraw(w, elem);
-		freeMagic(elem->stylelist);
+		free_magic1_t mm1 = freeMagic1_init();
+		freeMagic1(&mm1, elem->stylelist);
 		elem->stylelist = elem->stylelist->next;
+		freeMagic1_end(&mm1);
 		if (elem->stylelist == NULL)
 		    TxPrintf("Warning:  Element %s has no styles!\n", ename);
 	    }
@@ -1169,8 +1176,10 @@ DBWElementStyle(MagWindow *w, char *ename, int style, bool add)
 	    else if (sptr->next != NULL)
 	    {
 		dbwElementUndraw(w, elem);
-		freeMagic(sptr->next);
+		free_magic1_t mm1 = freeMagic1_init();
+		freeMagic1(&mm1, sptr->next);
 		sptr->next = sptr->next->next;
+		freeMagic1_end(&mm1);
 	    }
 	}
 	/* mark element's cell as having been modified */
@@ -1279,8 +1288,10 @@ DBWElementClearDef(cellDef)
 	if (!elem) continue;
 	if (elem->rootDef != cellDef) continue;
 
+	free_magic1_t mm1 = freeMagic1_init();
 	for (stylePtr = elem->stylelist; stylePtr != NULL; stylePtr = stylePtr->next)
-	    freeMagic(stylePtr);
+	    freeMagic1(&mm1, stylePtr);
+	freeMagic1_end(&mm1);
 
 	if (elem->type == ELEMENT_TEXT)
 	    freeMagic(elem->text);

dbwind/DBWfdback.c

@@ -249,7 +249,10 @@ DBWFeedbackRedraw(window, plane)
 }
 
 int
-dbwFeedbackAlways1()
+dbwFeedbackAlways1(
+    Tile *tile,			/* (unused) */
+    TileType dinfo,		/* (unused) */
+    ClientData clientdata)	/* (unused) */
 {
     return 1;
 }
@@ -528,8 +531,11 @@ dbwfbGetTransform(use, transform, cdarg)
  * cell.
  */
 
+/*ARGSUSED*/
 int
-dbwfbWindFunc()
+dbwfbWindFunc(w, clientData)
+    MagWindow *w;		/* UNUSED */
+    ClientData clientData;	/* UNUSED */
 {
     return 1;
 }

dbwind/DBWhlights.c

@@ -357,9 +357,11 @@ DBWHLRedrawPrepWindow(MagWindow *window, Rect *area)
  * ----------------------------------------------------------------------------
  */
 
+/*ARGSUSED*/
 int
-DBWHLRedrawWind(window)
+DBWHLRedrawWind(window, clientData)
     MagWindow *window;		/* Window in which to redraw highlights. */
+    ClientData clientData;	/* UNUSED */
 {
     int i;
     DBWclientRec *crec;
@@ -392,8 +394,9 @@ DBWHLRedrawWind(window)
  */
 
 int
-dbwhlEraseFunc(tile, window)
+dbwhlEraseFunc(tile, dinfo, window)
     Tile *tile;			/* Tile describing area to be erased.	*/
+    TileType dinfo;		/* Split tile information (unused)	*/
     MagWindow *window;		/* Window that is being altered.	*/
 {
     Rect area;

dbwind/DBWprocs.c

@@ -25,6 +25,7 @@ static char rcsid[] __attribute__ ((unused)) = "$Header: /usr/cvsroot/magic-8.0/
 #include <string.h>
 #include <sys/stat.h>
 
+#include "tcltk/tclmagic.h"
 #include "utils/main.h"
 #include "utils/magic.h"
 #include "utils/geometry.h"
@@ -33,6 +34,7 @@ static char rcsid[] __attribute__ ((unused)) = "$Header: /usr/cvsroot/magic-8.0/
 #include "utils/hash.h"
 #include "database/database.h"
 #include "utils/main.h"
+#include "cif/cif.h"
 #include "commands/commands.h"
 #include "dbwind/dbwind.h"
 #include "graphics/graphics.h"
@@ -544,12 +546,12 @@ DBWloadWindow(window, name, flags)
 	newEditUse = DBCellNewUse(newEditDef, (char *) NULL);
 	(void) StrDup(&(newEditUse->cu_id), "Topmost cell in the window");
 	DBExpand(newEditUse,
-		((DBWclientRec *)window->w_clientData)->dbw_bitmask, TRUE);
+		((DBWclientRec *)window->w_clientData)->dbw_bitmask, DB_EXPAND);
 
 	if (expand)
 	    DBExpandAll(newEditUse, &(newEditUse->cu_bbox),
 			((DBWclientRec *)window->w_clientData)->dbw_bitmask,
-			FALSE, UnexpandFunc,
+			DB_UNEXPAND, UnexpandFunc,
 			INT2CD(((DBWclientRec *)window->w_clientData)->dbw_bitmask));
 
 	if (newEdit)
@@ -653,6 +655,311 @@ DBWexit()
     return (CmdWarnWrite() == 1);
 }
 
+/*
+ * ----------------------------------------------------------------------------
+ *
+ * dbwValueFormat ---
+ *
+ *	Remove unnecessary trailing zeros and decimal from a floating-point
+ *	value formatted with "%.Nf" where N is the expected maximum number
+ *	of places after the decimal, matching the argument "places".
+ *	This makes the "%f" formatting work like "%g" formatting, but
+ *	works around the limitation of "%.Ng" that it operates on the number
+ *	of significant digits, not the number of decimal places.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	The string "buf" may be altered with a new terminating null character.
+ *
+ * ----------------------------------------------------------------------------
+ */
+
+void
+dbwValueFormat(char *buf,
+    int places)
+{
+    char *p = buf + strlen(buf) - 1;
+    while (p > buf && *p == '0') *p-- = '\0';
+    if (p > buf && *p == '.') *p = '\0';
+}
+
+/*
+ * ----------------------------------------------------------------------------
+ *
+ * dbwPrintValue0 --
+ *
+ *	Convert a value in internal database units to a string based on
+ *	the chosen display units as defined by DBWUnits (which is set
+ *	with the "units" command).  If DBWUnits has not been changed
+ *	since startup, then the behavior is to print the internal units
+ *	in string form.  If DBWUnits has been set, then the units type
+ *	determines how the output is displayed.
+ *
+ *	If "is_square" is TRUE, then the value is in units squared, and
+ *	scaling is done accordingly.  In the case of DBW_UNITS_USER,
+ *	where values are in grid multiples, the units for X and Y may
+ *	differ, and "is_x" = TRUE indicates a measurement in the X direction,
+ *	while false indicase a measurements in the Y direction.  Naturally,
+ *	if "is_square" is TRUE then "is_x" is ignored.  "is_x" is also ignored
+ *	for any output units other than user/grid units.
+ *
+ *	If "is_cif" is true, then "value" is in CIF database units
+ *	(centimicrons, nanometers, or angstroms, according to the
+ *	scalefactor line in the tech file), rather than internal units.
+ *
+ *	This routine is generally meant to be called as one of the three
+ *	variants defined below it:  DBWPrintValue(), DBWPrintSqValue(),
+ *	or DBWPrintCIFValue().
+ *
+ * Results:
+ *	A pointer to a string.  To facilitate printing up to four values
+ *	(e.g., rectangle coordinates, such as from "box values"), a static
+ *	string partitioned into four parts is created in this subroutine,
+ *	and the result points to one position in the string, which is cycled
+ *	through every four calls to the subroutine.  The caller does not
+ *	free the returned string.
+ *
+ * Side effects:
+ *	None.
+ *
+ * NOTE:  Prior to the introduction of the "units" command, magic had the
+ *	inconsistent behavior that parsed input values on the command line
+ *	would be interpreted per the "snap" setting, but output values were
+ *	(almost) always given in internal units.  This routine keeps the
+ *	original behavior backwards-compatible, as inconsistent as it is.
+ *
+ * ----------------------------------------------------------------------------
+ */
+
+char *
+dbwPrintValue0(int value,	/* value to print, in internal units */
+    MagWindow *w,		/* current window, for use with grid */
+    bool is_x,			/* TRUE if value is an X dimension */
+    bool is_square,		/* TRUE if value is a dimension squared */
+    bool is_cif)		/* TRUE if value is in centimicrons */
+{
+    char *result;
+    float oscale, dscale, fvalue;
+    DBWclientRec *crec;
+    int locunits;
+
+    /* This routine is called often, so avoid constant use of malloc and
+     * free by keeping up to four printed results in static memory.
+     */
+    static char resultstr[128];
+    static unsigned char resultpos = 0;
+
+    result = &resultstr[resultpos];
+    resultpos += 32;
+    resultpos &= 127;	/* At 128, cycle back to zero */
+
+    /* CIF database units are centimicrons/nanometers/angstroms as
+     * set by the "scalefactor" line in the tech file.  When "is_cif"
+     * is TRUE, then "value" is in these units.  Find the conversion
+     * factor to convert "value" to internal units, and then it can
+     * be subsequently converted to lambda, microns, etc.
+     */
+    if (is_cif == TRUE)
+	dscale = CIFGetScale(100) / CIFGetOutputScale(1000);
+    else
+	dscale = 1.0;
+
+    /* When printing user/grid units, check for a valid window */
+
+    locunits = DBWUnits;
+    if (locunits != DBW_UNITS_DEFAULT) locunits &= DBW_UNITS_TYPE_MASK;
+
+    /* The MagWindow argument is only needed for user units, since the
+     * user grid values are found there.  Setting MagWindow to NULL
+     * effectively disables printing values in user grid units, which
+     * then default to internal units.
+     */
+    if (locunits == DBW_UNITS_USER)
+    {
+	if (w == (MagWindow *)NULL)
+	{
+	    windCheckOnlyWindow(&w, DBWclientID);
+	    if (w == (MagWindow *)NULL)
+		locunits = DBW_UNITS_DEFAULT;
+	}
+    }
+
+    switch (locunits)
+    {
+	case DBW_UNITS_DEFAULT:
+	    snprintf(result, 32, "%d", value);
+	    break;
+
+	case DBW_UNITS_INTERNAL:
+	    if (is_cif)
+	    {
+		if (is_square)
+		{
+		    snprintf(result, 32, "%.6f", value * dscale * dscale);
+		    dbwValueFormat(result, 6);
+		}
+		else
+		{
+		    snprintf(result, 32, "%.3f", value * dscale);
+		    dbwValueFormat(result, 3);
+		}
+	    }
+	    else
+		snprintf(result, 32, "%d", value);
+	    if (is_square)
+	    {
+		if ((DBWUnits & DBW_UNITS_PRINT_FLAG) && (strlen(result) < 29))
+		    strcat(result, "i^2");
+	    }
+	    else
+	    {
+		if ((DBWUnits & DBW_UNITS_PRINT_FLAG) && (strlen(result) < 31))
+		    strcat(result, "i");
+	    }
+	    break;
+
+	case DBW_UNITS_LAMBDA:
+	
+	    oscale = (float)DBLambda[0];
+	    oscale /= (float)DBLambda[1];
+	    if (is_square)
+	    {
+		fvalue = (float)value * oscale * oscale * dscale * dscale;
+		snprintf(result, 32, "%0.6f", (double)fvalue);
+		dbwValueFormat(result, 6);
+		if ((DBWUnits & DBW_UNITS_PRINT_FLAG) && (strlen(result) < 29))
+		    strcat(result, "l^2");
+	    }
+	    else
+	    {
+		fvalue = (float)value * oscale * dscale;
+		snprintf(result, 32, "%0.3f", (double)fvalue);
+		dbwValueFormat(result, 3);
+		if ((DBWUnits & DBW_UNITS_PRINT_FLAG) && (strlen(result) < 31))
+		    strcat(result, "l");
+	    }
+	    break;
+
+	case DBW_UNITS_MICRONS:
+	    oscale = CIFGetOutputScale(1000);
+	    if (is_square)
+	    {
+		fvalue = (float)value * oscale * oscale * dscale * dscale;
+		snprintf(result, 32, "%0.6f", (double)fvalue);
+		dbwValueFormat(result, 6);
+		if ((DBWUnits & DBW_UNITS_PRINT_FLAG) && (strlen(result) < 28))
+		    strcat(result, "um^2");
+	    }
+	    else
+	    {
+		fvalue = (float)value * oscale * dscale;
+		snprintf(result, 32, "%0.3f", (double)fvalue);
+		dbwValueFormat(result, 3);
+		if ((DBWUnits & DBW_UNITS_PRINT_FLAG) && (strlen(result) < 30))
+		    strcat(result, "um");
+	    }
+	    break;
+
+	case DBW_UNITS_USER:
+	    if (is_square)
+	    {
+		oscale = (float)((crec->dbw_gridRect.r_xtop -
+			 crec->dbw_gridRect.r_xbot) *
+			(crec->dbw_gridRect.r_ytop -
+			crec->dbw_gridRect.r_ybot));
+	    }
+	    else if (is_x)
+	    {
+		oscale = (float)(crec->dbw_gridRect.r_xtop -
+			 crec->dbw_gridRect.r_xbot);
+	    }
+	    else
+	    {
+		oscale = (float)(crec->dbw_gridRect.r_ytop -
+			 crec->dbw_gridRect.r_ybot);
+	    }
+	    fvalue = (float)value * oscale * dscale;
+	    if (is_square)
+	    {
+		fvalue *= dscale;
+		snprintf(result, 32, "%0.6f", (double)fvalue);
+		dbwValueFormat(result, 6);
+		if ((DBWUnits & DBW_UNITS_PRINT_FLAG) && (strlen(result) < 27))
+		    strcat(result, "gx*gy");
+	    }
+	    else
+	    {
+		snprintf(result, 32, "%0.3f", (double)fvalue);
+		dbwValueFormat(result, 3);
+		if (is_x)
+		{
+		    if ((DBWUnits & DBW_UNITS_PRINT_FLAG) && (strlen(result) < 30))
+		        strcat(result, "gx");
+		}
+		else
+		{
+		    if ((DBWUnits & DBW_UNITS_PRINT_FLAG) && (strlen(result) < 30))
+		        strcat(result, "gy");
+		}
+	    }
+	    break;
+    }
+    return result;
+}
+
+/*
+ * ----------------------------------------------------------------------------
+ *
+ * DBWPrintValue --
+ * DBWPrintSqValue --
+ * DBWPrintCIFValue --
+ * DBWPrintCIFSqValue --
+ *
+ *	Convenience functions which call dbwPrintValue0() with specific
+ *	fixed arguments, so that the calls are not full of boolean values.
+ *	The "is_x" boolean is retained because it is used often.
+ *
+ * ----------------------------------------------------------------------------
+ */
+
+char *
+DBWPrintValue(int value,	/* value to print, in internal units */
+    MagWindow *w,		/* current window, for use with grid */
+    bool is_x)			/* TRUE if value is an X dimension */
+{
+    /* Call dbwPrintValue0() with is_square = FALSE and is_cif = FALSE */
+    return dbwPrintValue0(value, w, is_x, FALSE, FALSE);
+}
+
+char *
+DBWPrintSqValue(int value,	/* value to print, in internal units */
+    MagWindow *w)		/* current window, for use with grid */
+{
+    /* Call dbwPrintValue0() with is_square = TRUE and is_cif = FALSE */
+    /* is_x is set to TRUE although it is unused. */
+    return dbwPrintValue0(value, w, TRUE, TRUE, FALSE);
+}
+
+char *
+DBWPrintCIFValue(int value,	/* value to print, in internal units */
+    MagWindow *w,		/* current window, for use with grid */
+    bool is_x)			/* TRUE if value is an X dimension */
+{
+    /* Call dbwPrintValue0() with is_square = FALSE and is_cif = TRUE */
+    return dbwPrintValue0(value, w, is_x, FALSE, TRUE);
+}
+
+char *
+DBWPrintCIFSqValue(int value,	/* value to print, in internal units */
+    MagWindow *w)		/* current window, for use with grid */
+{
+    /* Call dbwPrintValue0() with is_square = TRUE and is_cif = TRUE */
+    /* is_x is set to TRUE although it is unused. */
+    return dbwPrintValue0(value, w, TRUE, TRUE, TRUE);
+}
+
 /*
  * ----------------------------------------------------------------------------
  *