# Contributor: Natanael Copa <ncopa@alpinelinux.org>
# Maintainer: Natanael Copa <ncopa@alpinelinux.org>
global pkgname := 'kbd'
global pkgver := '2.0.4'
global pkgrel := '2'
global pkgdesc := '"Tools for configuring the console (keyboard, virtual terminals, etc.)'"
global url := '"http://ftp.altlinux.org/pub/people/legion/kbd'"
global arch := '"all'"
global license := '"GPL2+'"
global depends := '"kbd-misc'"
global makedepends := '"linux-headers linux-pam-dev check-dev ckbcomp xkeyboard-config'"
global install := ''""
global subpackages := ""$pkgname-bkeymaps::noarch $pkgname-legacy::noarch $pkgname-misc::noarch $pkgname-doc $pkgname-vlock""
global source := ""http://kbd-project.org/download/kbd-$pkgver.tar.gz
	error.h
	fix-tests.patch
	""
global builddir := ""$srcdir"/kbd-$pkgver"
global _datadir := '/usr/share'
global _xmapdir := ""$_datadir"/keymaps/xkb"
global _bmapdir := ""$_datadir"/bkeymaps"
global _badmaps := '"pk-ara'"

proc prepare {
	default_prepare

	cd $builddir
	cp "$srcdir"/error.h .
}

proc build {
	cd $builddir
	./configure \
		--build=$CBUILD \
		--host=$CHOST \
		--disable-nls \
		--prefix=/usr \
		--datadir="$_datadir" \
		--htmldir=/usr/share/html/$pkgname
	make
}

proc check {
	cd $builddir
	make check
}

proc _listxmaps {
	var invariant = '', line = ''; invariant := 'false'
	grep -v '^$' /usr/share/X11/xkb/rules/base.lst | while read line {
	matchstr $line {
		'! variant' { invariant := 'true' }
		'!'* { invariant := 'false' }
		* { if $invariant {
			echo $line | cut -d: -f1
		} }
		}
	}
}

proc package {
	cd $builddir
	make DESTDIR="$pkgdir" install

	# Move and fixup legacy keymaps
	mkdir legacy
	mv "$pkgdir"/usr/share/keymaps/* legacy
	mv legacy "$pkgdir"/usr/share/keymaps

	cd "$pkgdir"/usr/share/keymaps/legacy/i386
	# Make ISO-8815-9 maps the default, instead of 7-bit ones
	ln -s pt-latin9.map.gz qwerty/pt.map.gz
	mv azerty/fr.map.gz azerty/fr-old.map.gz
	ln -s fr-latin9.map.gz azerty/fr.map.gz

	# Add some legacy aliases
	ln -s fr-latin9.map.gz azerty/fr-latin0.map.gz
	ln -s sv-latin1.map.gz qwerty/se-latin1.map.gz
	ln -s sr-cy.map.gz qwerty/sr-latin.map.gz

	# Rename conflicting keymaps
	mv dvorak/no.map.gz dvorak/no-dvorak.map.gz
	mv fgGIod/trf.map.gz fgGIod/trf-fgGIod.map.gz
	mv olpc/es.map.gz olpc/es-olpc.map.gz
	mv olpc/pt.map.gz olpc/pt-olpc.map.gz
	mv qwerty/cz.map.gz qwerty/cz-qwerty.map.gz

	# Remove useless layouts
	rm -f i386/qwerty/ro_win.map.gz

	cd $builddir

	# Compile keymaps from X.org layouts
	mkdir -p "$pkgdir$_xmapdir"
	var layout = '', variant = ''
	_listxmaps | while read -r variant layout {
		if ! test -f "$pkgdir$_xmapdir"/"$layout".map.gz {
			echo "Generating keymap $layout..."
			ckbcomp $layout | gzip > "$pkgdir$_xmapdir"/"$layout".map.gz || exit 1
		}
		echo "Generating keymap $layout-$variant..."
		ckbcomp $layout $variant | gzip > "$pkgdir$_xmapdir"/"$layout"-"$variant".map.gz || exit 1
	}

	# Do some fix-ups on X.org keymaps
	mv "$pkgdir$_xmapdir"/fi.map.gz "$pkgdir$_xmapdir"/fi-kotoistus.map.gz

	# Install html documentation
	mkdir -p "$pkgdir$_datadir"/html/$pkgname
	mv docs/doc/*.html "$pkgdir$_datadir"/html/$pkgname

	# Replace busybox setfont utility.
	mkdir -p "$pkgdir"/usr/sbin
	mv "$pkgdir"/usr/bin/setfont "$pkgdir"/usr/sbin

	# Link open to openvt
	ln -s openvt "$pkgdir"/usr/bin/open
}

proc vlock {
	global pkgdesc := ""$pkgname vlock implemantation""
	global depends := ''

	# This is the only binary needing linux-pam so moving this to a
	# subpackage reduces the amount of depencies of the kbd package.

	mkdir -p "$subpkgdir"/usr/bin
	mv "$pkgdir"/usr/bin/vlock "$subpkgdir"/usr/bin
}

proc bkeymaps {
	global pkgdesc := '"X.org-derived binary keymaps'"
	global depends := ''
	global replaces := '"bkeymaps'"
	global provides := '"bkeymaps'"

	mkdir -p "$subpkgdir$_bmapdir"
	var map = '', variant = '', layout = ''; for map in ["$pkgdir$_xmapdir"/*.map.gz] {
		variant := $[basename $map | cut -d. -f1]
		matchstr $variant { $_badmaps { continue } }

		layout := $(variant%%-*)
		mkdir -p "$subpkgdir$_bmapdir"/$layout
		echo "Generating binary keymap $variant..."
		"$pkgdir"/usr/bin/loadkeys -ub $map | gzip > "$subpkgdir$_bmapdir"/$layout/$variant.bmap.gz
	}
}

proc legacy {
	global pkgdesc := '"kbd legacy keymaps'"
	global depends := ''

	mkdir -p "$subpkgdir$_datadir"/keymaps
	mv "$pkgdir$_datadir"/keymaps/legacy "$subpkgdir$_datadir"/keymaps
}

proc misc {
	global pkgdesc := '"kbd keymaps and console data'"
	global depends := ''

	mkdir -p "$subpkgdir$_datadir"
	var dir = ''; for dir in [consolefonts consoletrans keymaps unimaps] {
		mv "$pkgdir$_datadir"/$dir "$subpkgdir$_datadir"
	}
}

global sha512sums := '"e37bc661c75a8363e9a5ba903310fa7f7ded4f381c2c77aa7edc0b1aca5a63224933fd113cddcf180e7fb85f55407e0d1f47be1cdf69dcf2787e83ac996bbf03  kbd-2.0.4.tar.gz
c66f6b0d8c8b8d285c740bdbe7130dee272ac01cd5e73b35a58cedf1a77fe8d9e062631b804fb58014d8eb9861c8f28aed07bc022ef31662bcc61b5c85a21752  error.h
bb67e5bb933a48f4a04402e07d7d67169a97485e6b469f8ccd4436466eb17ec2ddcf0ef74d22b3aae9e813feaee5bef0822ec50c384e0276a8c91f9325502a5f  fix-tests.patch'"
(CommandList
  children: [
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:pkgname) op:Equal rhs:{(kbd)} spids:[6])]
      spids: [6]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:pkgver) op:Equal rhs:{(2.0.4)} spids:[9])]
      spids: [9]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:pkgrel) op:Equal rhs:{(2)} spids:[12])]
      spids: [12]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:pkgdesc)
          op: Equal
          rhs: {(DQ ("Tools for configuring the console (keyboard, virtual terminals, etc.)"))}
          spids: [15]
        )
      ]
      spids: [15]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:url)
          op: Equal
          rhs: {(DQ ("http://ftp.altlinux.org/pub/people/legion/kbd"))}
          spids: [20]
        )
      ]
      spids: [20]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:arch) op:Equal rhs:{(DQ (all))} spids:[25])]
      spids: [25]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:license) op:Equal rhs:{(DQ ("GPL2+"))} spids:[30])]
      spids: [30]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:depends) op:Equal rhs:{(DQ (kbd-misc))} spids:[35])]
      spids: [35]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:makedepends)
          op: Equal
          rhs: {(DQ ("linux-headers linux-pam-dev check-dev ckbcomp xkeyboard-config"))}
          spids: [40]
        )
      ]
      spids: [40]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:install) op:Equal rhs:{(DQ )} spids:[45])]
      spids: [45]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:subpackages)
          op: Equal
          rhs: 
            {
              (DQ ($ VSub_Name "$pkgname") ("-bkeymaps::noarch ") ($ VSub_Name "$pkgname") 
                ("-legacy::noarch ") ($ VSub_Name "$pkgname") ("-misc::noarch ") ($ VSub_Name "$pkgname") ("-doc ") ($ VSub_Name "$pkgname") 
                (-vlock)
              )
            }
          spids: [49]
        )
      ]
      spids: [49]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:source)
          op: Equal
          rhs: 
            {
              (DQ ("http://kbd-project.org/download/kbd-") ($ VSub_Name "$pkgver") (".tar.gz\n") 
                ("\terror.h\n") ("\tfix-tests.patch\n") ("\t")
              )
            }
          spids: [63]
        )
      ]
      spids: [63]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:builddir)
          op: Equal
          rhs: {(DQ ($ VSub_Name "$srcdir")) (/kbd-) ($ VSub_Name "$pkgver")}
          spids: [73]
        )
      ]
      spids: [73]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:_datadir) op:Equal rhs:{(/usr/share)} spids:[80])]
      spids: [80]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:_xmapdir)
          op: Equal
          rhs: {(DQ ($ VSub_Name "$_datadir")) (/keymaps/xkb)}
          spids: [83]
        )
      ]
      spids: [83]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:_bmapdir)
          op: Equal
          rhs: {(DQ ($ VSub_Name "$_datadir")) (/bkeymaps)}
          spids: [89]
        )
      ]
      spids: [89]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:_badmaps) op:Equal rhs:{(DQ (pk-ara))} spids:[95])]
      spids: [95]
    )
    (FuncDef
      name: prepare
      body: 
        (BraceGroup
          children: [
            (C {(default_prepare)})
            (C {(cd)} {(DQ ($ VSub_Name "$builddir"))})
            (C {(cp)} {(DQ ($ VSub_Name "$srcdir")) (/error.h)} {(.)})
          ]
          spids: [105]
        )
      spids: [101 104]
    )
    (FuncDef
      name: build
      body: 
        (BraceGroup
          children: [
            (C {(cd)} {(DQ ($ VSub_Name "$builddir"))})
            (C {(./configure)} {(--build) (Lit_Other "=") ($ VSub_Name "$CBUILD")} 
              {(--host) (Lit_Other "=") ($ VSub_Name "$CHOST")} {(--disable-nls)} {(--prefix) (Lit_Other "=") (/usr)} 
              {(--datadir) (Lit_Other "=") (DQ ($ VSub_Name "$_datadir"))} {(--htmldir) (Lit_Other "=") (/usr/share/html/) ($ VSub_Name "$pkgname")}
            )
            (C {(make)})
          ]
          spids: [135]
        )
      spids: [131 134]
    )
    (FuncDef
      name: check
      body: 
        (BraceGroup
          children: [(C {(cd)} {(DQ ($ VSub_Name "$builddir"))}) (C {(make)} {(check)})]
          spids: [194]
        )
      spids: [190 193]
    )
    (FuncDef
      name: _listxmaps
      body: 
        (BraceGroup
          children: [
            (Sentence
              child: 
                (Assignment
                  keyword: Assign_Local
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:invariant)
                      op: Equal
                      spids: [220]
                    )
                    (assign_pair lhs:(LhsName name:line) op:Equal spids:[222])
                  ]
                  spids: [218]
                )
              terminator: <Op_Semi ";">
            )
            (Assignment
              keyword: Assign_None
              pairs: [(assign_pair lhs:(LhsName name:invariant) op:Equal rhs:{(false)} spids:[225])]
              spids: [225]
            )
            (Pipeline
              children: [
                (C {(grep)} {(-v)} {(SQ <"^$">)} {(/usr/share/X11/xkb/rules/base.lst)})
                (While
                  cond: [(Sentence child:(C {(read)} {(line)}) terminator:<Op_Semi ";">)]
                  body: 
                    (DoGroup
                      children: [
                        (Case
                          to_match: {(DQ ($ VSub_Name "$line"))}
                          arms: [
                            (case_arm
                              pat_list: [{(SQ <"! variant">)}]
                              action: [
                                (Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (LhsName name:invariant)
                                      op: Equal
                                      rhs: {(true)}
                                      spids: [265]
                                    )
                                  ]
                                  spids: [265]
                                )
                              ]
                              spids: [261 263 268 -1]
                            )
                            (case_arm
                              pat_list: [{(SQ <"!">) (Lit_Other "*")}]
                              action: [
                                (Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (LhsName name:invariant)
                                      op: Equal
                                      rhs: {(false)}
                                      spids: [277]
                                    )
                                  ]
                                  spids: [277]
                                )
                              ]
                              spids: [272 275 280 -1]
                            )
                            (case_arm
                              pat_list: [{(Lit_Other "*")}]
                              action: [
                                (If
                                  arms: [
                                    (if_arm
                                      cond: [
                                        (Sentence
                                          child: (C {($ VSub_Name "$invariant")})
                                          terminator: <Op_Semi ";">
                                        )
                                      ]
                                      action: [
                                        (Pipeline
                                          children: [
                                            (C {(echo)} {(DQ ($ VSub_Name "$line"))})
                                            (C {(cut)} {(-d) (Lit_Other ":")} {(-f1)})
                                          ]
                                          negated: False
                                        )
                                      ]
                                      spids: [-1 291]
                                    )
                                  ]
                                  spids: [-1 310]
                                )
                              ]
                              spids: [283 284 312 -1]
                            )
                          ]
                          spids: [251 257 315]
                        )
                      ]
                      spids: [248 318]
                    )
                )
              ]
              negated: False
            )
          ]
          spids: [215]
        )
      spids: [211 214]
    )
    (FuncDef
      name: package
      body: 
        (BraceGroup
          children: [
            (C {(cd)} {(DQ ($ VSub_Name "$builddir"))})
            (C {(make)} {(Lit_VarLike "DESTDIR=") (DQ ($ VSub_Name "$pkgdir"))} {(install)})
            (C {(mkdir)} {(legacy)})
            (C {(mv)} {(DQ ($ VSub_Name "$pkgdir")) (/usr/share/keymaps/) (Lit_Other "*")} {(legacy)})
            (C {(mv)} {(legacy)} {(DQ ($ VSub_Name "$pkgdir")) (/usr/share/keymaps)})
            (C {(cd)} {(DQ ($ VSub_Name "$pkgdir")) (/usr/share/keymaps/legacy/i386)})
            (C {(ln)} {(-s)} {(pt-latin9.map.gz)} {(qwerty/pt.map.gz)})
            (C {(mv)} {(azerty/fr.map.gz)} {(azerty/fr-old.map.gz)})
            (C {(ln)} {(-s)} {(fr-latin9.map.gz)} {(azerty/fr.map.gz)})
            (C {(ln)} {(-s)} {(fr-latin9.map.gz)} {(azerty/fr-latin0.map.gz)})
            (C {(ln)} {(-s)} {(sv-latin1.map.gz)} {(qwerty/se-latin1.map.gz)})
            (C {(ln)} {(-s)} {(sr-cy.map.gz)} {(qwerty/sr-latin.map.gz)})
            (C {(mv)} {(dvorak/no.map.gz)} {(dvorak/no-dvorak.map.gz)})
            (C {(mv)} {(fgGIod/trf.map.gz)} {(fgGIod/trf-fgGIod.map.gz)})
            (C {(mv)} {(olpc/es.map.gz)} {(olpc/es-olpc.map.gz)})
            (C {(mv)} {(olpc/pt.map.gz)} {(olpc/pt-olpc.map.gz)})
            (C {(mv)} {(qwerty/cz.map.gz)} {(qwerty/cz-qwerty.map.gz)})
            (C {(rm)} {(-f)} {(i386/qwerty/ro_win.map.gz)})
            (C {(cd)} {(DQ ($ VSub_Name "$builddir"))})
            (C {(mkdir)} {(-p)} {(DQ ($ VSub_Name "$pkgdir") ($ VSub_Name "$_xmapdir"))})
            (Assignment
              keyword: Assign_Local
              pairs: [
                (assign_pair lhs:(LhsName name:layout) op:Equal spids:[525])
                (assign_pair lhs:(LhsName name:variant) op:Equal spids:[527])
              ]
              spids: [523]
            )
            (Pipeline
              children: [
                (C {(_listxmaps)})
                (While
                  cond: [
                    (Sentence
                      child: (C {(read)} {(-r)} {(variant)} {(layout)})
                      terminator: <Op_Semi ";">
                    )
                  ]
                  body: 
                    (DoGroup
                      children: [
                        (If
                          arms: [
                            (if_arm
                              cond: [
                                (Sentence
                                  child: 
                                    (Pipeline
                                      children: [
                                        (C {(test)} {(-f)} 
                                          {(DQ ($ VSub_Name "$pkgdir") ($ VSub_Name "$_xmapdir")) 
                                            (/) (DQ ($ VSub_Name "$layout")) (.map.gz)
                                          }
                                        )
                                      ]
                                      negated: True
                                    )
                                  terminator: <Op_Semi ";">
                                )
                              ]
                              action: [
                                (C {(echo)} {(DQ ("Generating keymap ") ($ VSub_Name "$layout") (...))})
                                (AndOr
                                  children: [
                                    (Pipeline
                                      children: [
                                        (C {(ckbcomp)} {(DQ ($ VSub_Name "$layout"))})
                                        (SimpleCommand
                                          words: [{(gzip)}]
                                          redirects: [
                                            (Redir
                                              op_id: Redir_Great
                                              fd: -1
                                              arg_word: 
                                                {
                                                  (DQ ($ VSub_Name "$pkgdir") 
                                                    ($ VSub_Name "$_xmapdir")
                                                  ) (/) (DQ ($ VSub_Name "$layout")) (.map.gz)
                                                }
                                              spids: [589]
                                            )
                                          ]
                                        )
                                      ]
                                      negated: False
                                    )
                                    (C {(exit)} {(1)})
                                  ]
                                  op_id: Op_DPipe
                                )
                              ]
                              spids: [-1 567]
                            )
                          ]
                          spids: [-1 608]
                        )
                        (C {(echo)} 
                          {
                            (DQ ("Generating keymap ") ($ VSub_Name "$layout") (-) 
                              ($ VSub_Name "$variant") (...)
                            )
                          }
                        )
                        (AndOr
                          children: [
                            (Pipeline
                              children: [
                                (C {(ckbcomp)} {(DQ ($ VSub_Name "$layout"))} 
                                  {(DQ ($ VSub_Name "$variant"))}
                                )
                                (SimpleCommand
                                  words: [{(gzip)}]
                                  redirects: [
                                    (Redir
                                      op_id: Redir_Great
                                      fd: -1
                                      arg_word: 
                                        {(DQ ($ VSub_Name "$pkgdir") ($ VSub_Name "$_xmapdir")) (/) 
                                          (DQ ($ VSub_Name "$layout")) (-) (DQ ($ VSub_Name "$variant")) (.map.gz)
                                        }
                                      spids: [636]
                                    )
                                  ]
                                )
                              ]
                              negated: False
                            )
                            (C {(exit)} {(1)})
                          ]
                          op_id: Op_DPipe
                        )
                      ]
                      spids: [545 659]
                    )
                )
              ]
              negated: False
            )
            (C {(mv)} {(DQ ($ VSub_Name "$pkgdir") ($ VSub_Name "$_xmapdir")) (/fi.map.gz)} 
              {(DQ ($ VSub_Name "$pkgdir") ($ VSub_Name "$_xmapdir")) (/fi-kotoistus.map.gz)}
            )
            (C {(mkdir)} {(-p)} 
              {(DQ ($ VSub_Name "$pkgdir") ($ VSub_Name "$_datadir")) (/html/) 
                ($ VSub_Name "$pkgname")
              }
            )
            (C {(mv)} {(docs/doc/) (Lit_Other "*") (.html)} 
              {(DQ ($ VSub_Name "$pkgdir") ($ VSub_Name "$_datadir")) (/html/) 
                ($ VSub_Name "$pkgname")
              }
            )
            (C {(mkdir)} {(-p)} {(DQ ($ VSub_Name "$pkgdir")) (/usr/sbin)})
            (C {(mv)} {(DQ ($ VSub_Name "$pkgdir")) (/usr/bin/setfont)} 
              {(DQ ($ VSub_Name "$pkgdir")) (/usr/sbin)}
            )
            (C {(ln)} {(-s)} {(openvt)} {(DQ ($ VSub_Name "$pkgdir")) (/usr/bin/open)})
          ]
          spids: [327]
        )
      spids: [323 326]
    )
    (FuncDef
      name: vlock
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:pkgdesc)
                  op: Equal
                  rhs: {(DQ ($ VSub_Name "$pkgname") (" vlock implemantation"))}
                  spids: [767]
                )
              ]
              spids: [767]
            )
            (Assignment
              keyword: Assign_None
              pairs: [(assign_pair lhs:(LhsName name:depends) op:Equal rhs:{(SQ )} spids:[774])]
              spids: [774]
            )
            (C {(mkdir)} {(-p)} {(DQ ($ VSub_Name "$subpkgdir")) (/usr/bin)})
            (C {(mv)} {(DQ ($ VSub_Name "$pkgdir")) (/usr/bin/vlock)} 
              {(DQ ($ VSub_Name "$subpkgdir")) (/usr/bin)}
            )
          ]
          spids: [764]
        )
      spids: [760 763]
    )
    (FuncDef
      name: bkeymaps
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:pkgdesc)
                  op: Equal
                  rhs: {(DQ ("X.org-derived binary keymaps"))}
                  spids: [819]
                )
              ]
              spids: [819]
            )
            (Assignment
              keyword: Assign_None
              pairs: [(assign_pair lhs:(LhsName name:depends) op:Equal rhs:{(SQ )} spids:[825])]
              spids: [825]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:replaces)
                  op: Equal
                  rhs: {(DQ (bkeymaps))}
                  spids: [828]
                )
              ]
              spids: [828]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:provides)
                  op: Equal
                  rhs: {(DQ (bkeymaps))}
                  spids: [834]
                )
              ]
              spids: [834]
            )
            (C {(mkdir)} {(-p)} {(DQ ($ VSub_Name "$subpkgdir") ($ VSub_Name "$_bmapdir"))})
            (Sentence
              child: 
                (Assignment
                  keyword: Assign_Local
                  pairs: [
                    (assign_pair lhs:(LhsName name:map) op:Equal spids:[853])
                    (assign_pair lhs:(LhsName name:variant) op:Equal spids:[855])
                    (assign_pair lhs:(LhsName name:layout) op:Equal spids:[857])
                  ]
                  spids: [851]
                )
              terminator: <Op_Semi ";">
            )
            (ForEach
              iter_name: map
              iter_words: [
                {(DQ ($ VSub_Name "$pkgdir") ($ VSub_Name "$_xmapdir")) (/) (Lit_Other "*") (.map.gz)}
              ]
              do_arg_iter: False
              body: 
                (DoGroup
                  children: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:variant)
                          op: Equal
                          rhs: 
                            {
                              (DQ 
                                (CommandSubPart
                                  command_list: 
                                    (CommandList
                                      children: [
                                        (Pipeline
                                          children: [
                                            (C {(basename)} {(DQ ($ VSub_Name "$map"))})
                                            (C {(cut)} {(-d.)} {(-f1)})
                                          ]
                                          negated: False
                                        )
                                      ]
                                    )
                                  left_token: <Left_CommandSub "$(">
                                  spids: [880 894]
                                )
                              )
                            }
                          spids: [878]
                        )
                      ]
                      spids: [878]
                    )
                    (Case
                      to_match: {(DQ ($ VSub_Name "$variant"))}
                      arms: [
                        (case_arm
                          pat_list: [{($ VSub_Name "$_badmaps")}]
                          action: [(ControlFlow token:<ControlFlow_Continue continue>)]
                          spids: [906 907 911 -1]
                        )
                      ]
                      spids: [898 904 913]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:layout)
                          op: Equal
                          rhs: 
                            {
                              (DQ 
                                (BracedVarSub
                                  token: <VSub_Name variant>
                                  suffix_op: (StringUnary op_id:VOp1_DPercent arg_word:{("-*")})
                                  spids: [919 923]
                                )
                              )
                            }
                          spids: [917]
                        )
                      ]
                      spids: [917]
                    )
                    (C {(mkdir)} {(-p)} 
                      {(DQ ($ VSub_Name "$subpkgdir") ($ VSub_Name "$_bmapdir")) (/) 
                        ($ VSub_Name "$layout")
                      }
                    )
                    (C {(echo)} {(DQ ("Generating binary keymap ") ($ VSub_Name "$variant") (...))})
                    (Pipeline
                      children: [
                        (C {(DQ ($ VSub_Name "$pkgdir")) (/usr/bin/loadkeys)} {(-ub)} 
                          {(DQ ($ VSub_Name "$map"))}
                        )
                        (SimpleCommand
                          words: [{(gzip)}]
                          redirects: [
                            (Redir
                              op_id: Redir_Great
                              fd: -1
                              arg_word: 
                                {(DQ ($ VSub_Name "$subpkgdir") ($ VSub_Name "$_bmapdir")) (/) 
                                  ($ VSub_Name "$layout") (/) ($ VSub_Name "$variant") (.bmap.gz)
                                }
                              spids: [963]
                            )
                          ]
                        )
                      ]
                      negated: False
                    )
                  ]
                  spids: [875 976]
                )
              spids: [865 873]
            )
          ]
          spids: [816]
        )
      spids: [812 815]
    )
    (FuncDef
      name: legacy
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:pkgdesc)
                  op: Equal
                  rhs: {(DQ ("kbd legacy keymaps"))}
                  spids: [988]
                )
              ]
              spids: [988]
            )
            (Assignment
              keyword: Assign_None
              pairs: [(assign_pair lhs:(LhsName name:depends) op:Equal rhs:{(SQ )} spids:[994])]
              spids: [994]
            )
            (C {(mkdir)} {(-p)} {(DQ ($ VSub_Name "$subpkgdir") ($ VSub_Name "$_datadir")) (/keymaps)})
            (C {(mv)} {(DQ ($ VSub_Name "$pkgdir") ($ VSub_Name "$_datadir")) (/keymaps/legacy)} 
              {(DQ ($ VSub_Name "$subpkgdir") ($ VSub_Name "$_datadir")) (/keymaps)}
            )
          ]
          spids: [985]
        )
      spids: [981 984]
    )
    (FuncDef
      name: misc
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:pkgdesc)
                  op: Equal
                  rhs: {(DQ ("kbd keymaps and console data"))}
                  spids: [1033]
                )
              ]
              spids: [1033]
            )
            (Assignment
              keyword: Assign_None
              pairs: [(assign_pair lhs:(LhsName name:depends) op:Equal rhs:{(SQ )} spids:[1039])]
              spids: [1039]
            )
            (C {(mkdir)} {(-p)} {(DQ ($ VSub_Name "$subpkgdir") ($ VSub_Name "$_datadir"))})
            (Sentence
              child: 
                (Assignment
                  keyword: Assign_Local
                  pairs: [(assign_pair lhs:(LhsName name:dir) op:Equal spids:[1055])]
                  spids: [1053]
                )
              terminator: <Op_Semi ";">
            )
            (ForEach
              iter_name: dir
              iter_words: [{(consolefonts)} {(consoletrans)} {(keymaps)} {(unimaps)}]
              do_arg_iter: False
              body: 
                (DoGroup
                  children: [
                    (C {(mv)} 
                      {(DQ ($ VSub_Name "$pkgdir") ($ VSub_Name "$_datadir")) (/) 
                        ($ VSub_Name "$dir")
                      } {(DQ ($ VSub_Name "$subpkgdir") ($ VSub_Name "$_datadir"))}
                    )
                  ]
                  spids: [1073 1091]
                )
              spids: [1063 1071]
            )
          ]
          spids: [1030]
        )
      spids: [1026 1029]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:sha512sums)
          op: Equal
          rhs: 
            {
              (DQ 
                (
"e37bc661c75a8363e9a5ba903310fa7f7ded4f381c2c77aa7edc0b1aca5a63224933fd113cddcf180e7fb85f55407e0d1f47be1cdf69dcf2787e83ac996bbf03  kbd-2.0.4.tar.gz\n"
                ) 
                (
"c66f6b0d8c8b8d285c740bdbe7130dee272ac01cd5e73b35a58cedf1a77fe8d9e062631b804fb58014d8eb9861c8f28aed07bc022ef31662bcc61b5c85a21752  error.h\n"
                ) 
                (
"bb67e5bb933a48f4a04402e07d7d67169a97485e6b469f8ccd4436466eb17ec2ddcf0ef74d22b3aae9e813feaee5bef0822ec50c384e0276a8c91f9325502a5f  fix-tests.patch"
                )
              )
            }
          spids: [1096]
        )
      ]
      spids: [1096]
    )
  ]
)