(command.CommandList
  children: [
    (command.ShAssignment
      pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:PROGRAM) op:Equal rhs:{(libtool)})]
    )
    (command.ShAssignment
      pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:PACKAGE) op:Equal rhs:{(libtool)})]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:VERSION)
          op: Equal
          rhs: {(DQ ('2.4.6 Debian-2.4.6-0.1'))}
        )
      ]
    )
    (command.ShAssignment
      pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:package_revision) op:Equal rhs:{(2.4.6)})]
    )
    (C {(Lit_Other ':')} 
      {
        (braced_var_sub
          token: <VSub_Name AUTOCONF>
          suffix_op: (suffix_op.Unary op_id:VTest_Equals arg_word:{(DQ (autoconf))})
        )
      }
    )
    (C {(Lit_Other ':')} 
      {
        (braced_var_sub
          token: <VSub_Name AUTOMAKE>
          suffix_op: (suffix_op.Unary op_id:VTest_Equals arg_word:{(DQ (automake))})
        )
      }
    )
    (command.Sentence
      child: 
        (command.ShAssignment
          pairs: [
            (assign_pair
              lhs: (sh_lhs_expr.Name name:scriptversion)
              op: Equal
              rhs: {(2015-01-20.17)}
            )
          ]
        )
      terminator: <Op_Semi ';'>
    )
    (command.CommandList
      children: [
        (command.Sentence
          child: 
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:DUALCASE) op:Equal rhs:{(1)})]
            )
          terminator: <Op_Semi ';'>
        )
        (C {(export)} {(DUALCASE)})
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: [
            (command.Sentence
              child: 
                (command.AndOr
                  ops: [Op_DAmp]
                  children: [
                    (C {(test)} {(-n)} 
                      {
                        (DQ 
                          (braced_var_sub
                            token: <VSub_Name ZSH_VERSION>
                            suffix_op: (suffix_op.Unary op_id:VTest_Plus arg_word:{(set)})
                          )
                        )
                      }
                    )
                    (command.Subshell
                      command_list: (command.CommandList children:[(C {(emulate)} {(sh)})])
                      redirects: [
                        (redir.Redir
                          op: <Redir_Great '>'>
                          fd: 16777215
                          arg_word: {(/dev/null)}
                        )
                        (redir.Redir
                          op: <Redir_GreatAnd '2>&'>
                          fd: 2
                          arg_word: {(1)}
                        )
                      ]
                    )
                  ]
                )
              terminator: <Op_Semi ';'>
            )
          ]
          action: [
            (C {(Lit_Other ':')})
            (C {(emulate)} {(sh)})
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:NULLCMD) op:Equal rhs:{(Lit_Other ':')})]
            )
            (C {(alias)} {(-g)} {(SQ <'${1+"$@"}'>) (Lit_Equals '=') (SQ <'"$@"'>)})
            (C {(setopt)} {(NO_GLOB_SUBST)})
          ]
        )
      ]
      else_action: [
        (command.Case
          to_match: 
            {
              (command_sub
                left_token: <Left_Backtick '`'>
                command_list: 
                  (command.CommandList
                    children: [
                      (command.Subshell
                        command_list: (command.CommandList children:[(C {(KW_Set set)} {(-o)})])
                        redirects: [(redir.Redir op:<Redir_Great '2>'> fd:2 arg_word:{(/dev/null)})]
                      )
                    ]
                  )
              )
            }
          arms: [
            (case_arm
              pat_list: [{(Lit_Star '*') (posix) (Lit_Star '*')}]
              action: [(C {(KW_Set set)} {(-o)} {(posix)})]
            )
          ]
        )
      ]
    )
    (command.ShAssignment
      pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:_G_user_locale) op:Equal rhs:(word.Empty))]
    )
    (command.ShAssignment
      pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:_G_safe_locale) op:Equal rhs:(word.Empty))]
    )
    (command.ForEach
      iter_name: _G_var
      iter_words: [{(LANG)} {(LANGUAGE)} {(LC_ALL)} {(LC_CTYPE)} {(LC_COLLATE)} {(LC_MESSAGES)}]
      do_arg_iter: F
      body: 
        (command.DoGroup
          children: [
            (C {(eval)} 
              {
                (DQ ('if test set = ') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) ('{') ($ VSub_DollarName '$_G_var') ('+set}') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) 
                  ('; then\n') ('          save_') ($ VSub_DollarName '$_G_var') ('=') 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) ($ VSub_DollarName '$_G_var') ('\n') ('          ') ($ VSub_DollarName '$_G_var') ('=C\n') ('\t  export ') 
                  ($ VSub_DollarName '$_G_var') ('\n') ('\t  _G_user_locale=') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) 
                  ($ VSub_DollarName '$_G_var') ('=') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\\\'>) 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) (save_) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) ('_G_var; ') 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) (_G_user_locale) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) ('\n') ('\t  _G_safe_locale=') 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) ($ VSub_DollarName '$_G_var') ('=C; ') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) 
                  (_G_safe_locale) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) ('\n') ('\tfi')
                )
              }
            )
          ]
        )
    )
    (command.AndOr
      ops: [Op_DAmp]
      children: [
        (command.Subshell
          command_list: (command.CommandList children:[(C {(unset)} {(CDPATH)})])
          redirects: [
            (redir.Redir op:<Redir_Great '>'> fd:16777215 arg_word:{(/dev/null)})
            (redir.Redir op:<Redir_GreatAnd '2>&'> fd:2 arg_word:{(1)})
          ]
        )
        (C {(unset)} {(CDPATH)})
      ]
    )
    (command.ShAssignment
      pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:sp) op:Equal rhs:{(SQ <' '>)})]
    )
    (command.ShAssignment
      pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:nl) op:Equal rhs:{(SQ <'\n'>)})]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:IFS)
          op: Equal
          rhs: {(DQ ($ VSub_DollarName '$sp') ('\t') ($ VSub_DollarName '$nl'))}
        )
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: [
            (command.Sentence
              child: 
                (C {(test)} 
                  {
                    (DQ 
                      (braced_var_sub
                        token: <VSub_Name PATH_SEPARATOR>
                        suffix_op: (suffix_op.Unary op_id:VTest_Plus arg_word:{(set)})
                      )
                    )
                  } {(KW_Bang '!') (Lit_Equals '=')} {(KW_Set set)}
                )
              terminator: <Op_Semi ';'>
            )
          ]
          action: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:PATH_SEPARATOR)
                  op: Equal
                  rhs: {(Lit_Other ':')}
                )
              ]
            )
            (command.AndOr
              ops: [Op_DAmp]
              children: [
                (command.Subshell
                  command_list: 
                    (command.CommandList
                      children: [
                        (command.Sentence
                          child: 
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:PATH)
                                  op: Equal
                                  rhs: {(SQ <'/bin;/bin'>)}
                                )
                              ]
                            )
                          terminator: <Op_Semi ';'>
                        )
                        (command.Sentence
                          child: 
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:FPATH)
                                  op: Equal
                                  rhs: {($ VSub_DollarName '$PATH')}
                                )
                              ]
                            )
                          terminator: <Op_Semi ';'>
                        )
                        (C {(sh)} {(-c)} {(Lit_Other ':')})
                      ]
                    )
                  redirects: [
                    (redir.Redir
                      op: <Redir_Great '>'>
                      fd: 16777215
                      arg_word: {(/dev/null)}
                    )
                    (redir.Redir op:<Redir_GreatAnd '2>&'> fd:2 arg_word:{(1)})
                  ]
                )
                (command.BraceGroup
                  children: [
                    (command.AndOr
                      ops: [Op_DPipe]
                      children: [
                        (command.Subshell
                          command_list: 
                            (command.CommandList
                              children: [
                                (command.Sentence
                                  child: 
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:PATH)
                                          op: Equal
                                          rhs: {(SQ <'/bin:/bin'>)}
                                        )
                                      ]
                                    )
                                  terminator: <Op_Semi ';'>
                                )
                                (command.Sentence
                                  child: 
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:FPATH)
                                          op: Equal
                                          rhs: {($ VSub_DollarName '$PATH')}
                                        )
                                      ]
                                    )
                                  terminator: <Op_Semi ';'>
                                )
                                (C {(sh)} {(-c)} {(Lit_Other ':')})
                              ]
                            )
                          redirects: [
                            (redir.Redir
                              op: <Redir_Great '>'>
                              fd: 16777215
                              arg_word: {(/dev/null)}
                            )
                            (redir.Redir
                              op: <Redir_GreatAnd '2>&'>
                              fd: 2
                              arg_word: {(1)}
                            )
                          ]
                        )
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:PATH_SEPARATOR)
                              op: Equal
                              rhs: {(SQ <';'>)}
                            )
                          ]
                        )
                      ]
                    )
                  ]
                )
              ]
            )
          ]
        )
      ]
    )
    (command.ShFunction
      name: func_executable_p
      body: 
        (command.BraceGroup
          children: [
            (command.AndOr
              ops: [Op_DAmp]
              children: [
                (C {(test)} {(-f)} {(DQ ($ VSub_Number '$1'))})
                (C {(test)} {(-x)} {(DQ ($ VSub_Number '$1'))})
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: func_path_progs
      body: 
        (command.BraceGroup
          children: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:_G_progs_list)
                  op: Equal
                  rhs: {($ VSub_Number '$1')}
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:_G_check_func)
                  op: Equal
                  rhs: {($ VSub_Number '$2')}
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:_G_PATH)
                  op: Equal
                  rhs: 
                    {
                      (braced_var_sub
                        token: <VSub_Number 3>
                        suffix_op: 
                          (suffix_op.Unary
                            op_id: VTest_Hyphen
                            arg_word: {(DQ ($ VSub_DollarName '$PATH'))}
                          )
                      )
                    }
                )
              ]
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:_G_path_prog_max) op:Equal rhs:{(0)})]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:_G_path_prog_found)
                  op: Equal
                  rhs: {(false)}
                )
              ]
            )
            (command.Sentence
              child: 
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:_G_save_IFS)
                      op: Equal
                      rhs: {($ VSub_DollarName '$IFS')}
                    )
                  ]
                )
              terminator: <Op_Semi ';'>
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:IFS)
                  op: Equal
                  rhs: 
                    {
                      (braced_var_sub
                        token: <VSub_Name PATH_SEPARATOR>
                        suffix_op: (suffix_op.Unary op_id:VTest_Hyphen arg_word:{(':')})
                      )
                    }
                )
              ]
            )
            (command.ForEach
              iter_name: _G_dir
              iter_words: [{($ VSub_DollarName '$_G_PATH')}]
              do_arg_iter: F
              body: 
                (command.DoGroup
                  children: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:IFS)
                          op: Equal
                          rhs: {($ VSub_DollarName '$_G_save_IFS')}
                        )
                      ]
                    )
                    (command.AndOr
                      ops: [Op_DAmp]
                      children: [
                        (C {(test)} {(-z)} {(DQ ($ VSub_DollarName '$_G_dir'))})
                        (command.ShAssignment
                          pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:_G_dir) op:Equal rhs:{(.)})]
                        )
                      ]
                    )
                    (command.ForEach
                      iter_name: _G_prog_name
                      iter_words: [{($ VSub_DollarName '$_G_progs_list')}]
                      do_arg_iter: F
                      body: 
                        (command.DoGroup
                          children: [
                            (command.ForEach
                              iter_name: _exeext
                              iter_words: [{(SQ )} {(.EXE)}]
                              do_arg_iter: F
                              body: 
                                (command.DoGroup
                                  children: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:_G_path_prog)
                                          op: Equal
                                          rhs: 
                                            {($ VSub_DollarName '$_G_dir') (/) 
                                              ($ VSub_DollarName '$_G_prog_name') ($ VSub_DollarName '$_exeext')
                                            }
                                        )
                                      ]
                                    )
                                    (command.AndOr
                                      ops: [Op_DPipe]
                                      children: [
                                        (C {(func_executable_p)} 
                                          {(DQ ($ VSub_DollarName '$_G_path_prog'))}
                                        )
                                        (command.ControlFlow
                                          token: <ControlFlow_Continue continue>
                                        )
                                      ]
                                    )
                                    (command.Case
                                      to_match: 
                                        {
                                          (command_sub
                                            left_token: <Left_Backtick '`'>
                                            command_list: 
                                              (command.CommandList
                                                children: [
                                                  (command.Simple
                                                    words: [
                                                      {(DQ ($ VSub_DollarName '$_G_path_prog'))}
                                                      {(--version)}
                                                    ]
                                                    redirects: [
                                                      (redir.Redir
                                                        op: <Redir_GreatAnd '2>&'>
                                                        fd: 2
                                                        arg_word: {(1)}
                                                      )
                                                    ]
                                                  )
                                                ]
                                              )
                                          )
                                        }
                                      arms: [
                                        (case_arm
                                          pat_list: [{(Lit_Star '*') (GNU) (Lit_Star '*')}]
                                          action: [
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:func_path_progs_result)
                                                  op: Equal
                                                  rhs: {($ VSub_DollarName '$_G_path_prog')}
                                                )
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:_G_path_prog_found)
                                                  op: Equal
                                                  rhs: {(Lit_Other ':')}
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                        (case_arm
                                          pat_list: [{(Lit_Star '*')}]
                                          action: [
                                            (C {($ VSub_DollarName '$_G_check_func')} 
                                              {($ VSub_DollarName '$_G_path_prog')}
                                            )
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:func_path_progs_result)
                                                  op: Equal
                                                  rhs: {($ VSub_DollarName '$func_check_prog_result')}
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                    (command.AndOr
                                      ops: [Op_DAmp]
                                      children: [
                                        (C {($ VSub_DollarName '$_G_path_prog_found')})
                                        (command.ControlFlow
                                          token: <ControlFlow_Break break>
                                          arg_word: {(3)}
                                        )
                                      ]
                                    )
                                  ]
                                )
                            )
                          ]
                        )
                    )
                  ]
                )
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:IFS)
                  op: Equal
                  rhs: {($ VSub_DollarName '$_G_save_IFS')}
                )
              ]
            )
            (command.AndOr
              ops: [Op_DAmp]
              children: [
                (C {(test)} {(-z)} {(DQ ($ VSub_DollarName '$func_path_progs_result'))})
                (command.BraceGroup
                  children: [
                    (command.Simple
                      words: [
                        {(echo)}
                        {
                          (DQ ('no acceptable sed could be found in ') 
                            (word_part.EscapedLiteral
                              token: <Lit_EscapedChar '\\$'>
                            ) (PATH)
                          )
                        }
                      ]
                      redirects: [(redir.Redir op:<Redir_GreatAnd '>&'> fd:16777215 arg_word:{(2)})]
                    )
                    (command.ControlFlow
                      token: <ControlFlow_Exit exit>
                      arg_word: {(1)}
                    )
                  ]
                )
              ]
            )
          ]
        )
    )
    (command.AndOr
      ops: [Op_DAmp]
      children: [
        (C {(test)} {(-z)} {(DQ ($ VSub_DollarName '$SED'))})
        (command.BraceGroup
          children: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:_G_sed_script)
                  op: Equal
                  rhs: {(s/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb/)}
                )
              ]
            )
            (command.ForEach
              iter_name: _G_i
              iter_words: [{(1)} {(2)} {(3)} {(4)} {(5)} {(6)} {(7)}]
              do_arg_iter: F
              body: 
                (command.DoGroup
                  children: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:_G_sed_script)
                          op: Equal
                          rhs: 
                            {($ VSub_DollarName '$_G_sed_script') ($ VSub_DollarName '$nl') 
                              ($ VSub_DollarName '$_G_sed_script')
                            }
                        )
                      ]
                    )
                  ]
                )
            )
            (command.Pipeline
              children: [
                (command.Simple
                  words: [{(echo)} {(DQ ($ VSub_DollarName '$_G_sed_script'))}]
                  redirects: [(redir.Redir op:<Redir_Great '2>'> fd:2 arg_word:{(/dev/null)})]
                )
                (command.Simple
                  words: [{(sed)} {(99q)}]
                  redirects: [(redir.Redir op:<Redir_Great '>'> fd:16777215 arg_word:{(conftest.sed)})]
                )
              ]
              negated: F
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:_G_sed_script) op:Equal rhs:(word.Empty))]
            )
            (command.ShFunction
              name: func_check_prog_sed
              body: 
                (command.BraceGroup
                  children: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:_G_path_prog)
                          op: Equal
                          rhs: {($ VSub_Number '$1')}
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:_G_count) op:Equal rhs:{(0)})]
                    )
                    (command.Simple
                      words: [{(printf)} {(0123456789)}]
                      redirects: [
                        (redir.Redir
                          op: <Redir_Great '>'>
                          fd: 16777215
                          arg_word: {(conftest.in)}
                        )
                      ]
                    )
                    (command.WhileUntil
                      keyword: <KW_While while>
                      cond: [(C {(Lit_Other ':')})]
                      body: 
                        (command.DoGroup
                          children: [
                            (command.Simple
                              words: [{(cat)} {(conftest.in)} {(conftest.in)}]
                              redirects: [
                                (redir.Redir
                                  op: <Redir_Great '>'>
                                  fd: 16777215
                                  arg_word: {(conftest.tmp)}
                                )
                              ]
                            )
                            (C {(mv)} {(conftest.tmp)} {(conftest.in)})
                            (C {(cp)} {(conftest.in)} {(conftest.nl)})
                            (command.Simple
                              words: [{(echo)} {(SQ )}]
                              redirects: [
                                (redir.Redir
                                  op: <Redir_DGreat '>>'>
                                  fd: 16777215
                                  arg_word: {(conftest.nl)}
                                )
                              ]
                            )
                            (command.AndOr
                              ops: [Op_DPipe]
                              children: [
                                (command.Simple
                                  words: [
                                    {(DQ ($ VSub_DollarName '$_G_path_prog'))}
                                    {(-f)}
                                    {(conftest.sed)}
                                  ]
                                  redirects: [
                                    (redir.Redir
                                      op: <Redir_Less '<'>
                                      fd: 16777215
                                      arg_word: {(conftest.nl)}
                                    )
                                    (redir.Redir
                                      op: <Redir_Great '>'>
                                      fd: 16777215
                                      arg_word: {(conftest.out)}
                                    )
                                    (redir.Redir
                                      op: <Redir_Great '2>'>
                                      fd: 2
                                      arg_word: {(/dev/null)}
                                    )
                                  ]
                                )
                                (command.ControlFlow
                                  token: <ControlFlow_Break break>
                                )
                              ]
                            )
                            (command.AndOr
                              ops: [Op_DPipe]
                              children: [
                                (command.Simple
                                  words: [{(diff)} {(conftest.out)} {(conftest.nl)}]
                                  redirects: [
                                    (redir.Redir
                                      op: <Redir_Great '>'>
                                      fd: 16777215
                                      arg_word: {(/dev/null)}
                                    )
                                    (redir.Redir
                                      op: <Redir_GreatAnd '2>&'>
                                      fd: 2
                                      arg_word: {(1)}
                                    )
                                  ]
                                )
                                (command.ControlFlow
                                  token: <ControlFlow_Break break>
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:_G_count)
                                  op: Equal
                                  rhs: 
                                    {
                                      (command_sub
                                        left_token: <Left_Backtick '`'>
                                        command_list: 
                                          (command.CommandList
                                            children: [
                                              (C {(expr)} {($ VSub_DollarName '$_G_count')} 
                                                {(Lit_Other '+')} {(1)}
                                              )
                                            ]
                                          )
                                      )
                                    }
                                )
                              ]
                            )
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (C {(test)} {(DQ ($ VSub_DollarName '$_G_count'))} {(-gt)} 
                                          {(DQ ($ VSub_DollarName '$_G_path_prog_max'))}
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:func_check_prog_result)
                                          op: Equal
                                          rhs: {($ VSub_DollarName '$_G_path_prog')}
                                        )
                                      ]
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:_G_path_prog_max)
                                          op: Equal
                                          rhs: {($ VSub_DollarName '$_G_count')}
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.AndOr
                              ops: [Op_DAmp]
                              children: [
                                (C {(test)} {(10)} {(-lt)} {(DQ ($ VSub_DollarName '$_G_count'))})
                                (command.ControlFlow
                                  token: <ControlFlow_Break break>
                                )
                              ]
                            )
                          ]
                        )
                    )
                    (C {(rm)} {(-f)} {(conftest.in)} {(conftest.tmp)} {(conftest.nl)} {(conftest.out)})
                  ]
                )
            )
            (C {(func_path_progs)} {(DQ ('sed gsed'))} {(func_check_prog_sed)} 
              {($ VSub_DollarName '$PATH') (Lit_Other ':') (/usr/xpg4/bin)}
            )
            (C {(rm)} {(-f)} {(conftest.sed)})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:SED)
                  op: Equal
                  rhs: {($ VSub_DollarName '$func_path_progs_result')}
                )
              ]
            )
          ]
        )
      ]
    )
    (command.AndOr
      ops: [Op_DAmp]
      children: [
        (C {(test)} {(-z)} {(DQ ($ VSub_DollarName '$GREP'))})
        (command.BraceGroup
          children: [
            (command.ShFunction
              name: func_check_prog_grep
              body: 
                (command.BraceGroup
                  children: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:_G_path_prog)
                          op: Equal
                          rhs: {($ VSub_Number '$1')}
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:_G_count) op:Equal rhs:{(0)})]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:_G_path_prog_max)
                          op: Equal
                          rhs: {(0)}
                        )
                      ]
                    )
                    (command.Simple
                      words: [{(printf)} {(0123456789)}]
                      redirects: [
                        (redir.Redir
                          op: <Redir_Great '>'>
                          fd: 16777215
                          arg_word: {(conftest.in)}
                        )
                      ]
                    )
                    (command.WhileUntil
                      keyword: <KW_While while>
                      cond: [(C {(Lit_Other ':')})]
                      body: 
                        (command.DoGroup
                          children: [
                            (command.Simple
                              words: [{(cat)} {(conftest.in)} {(conftest.in)}]
                              redirects: [
                                (redir.Redir
                                  op: <Redir_Great '>'>
                                  fd: 16777215
                                  arg_word: {(conftest.tmp)}
                                )
                              ]
                            )
                            (C {(mv)} {(conftest.tmp)} {(conftest.in)})
                            (C {(cp)} {(conftest.in)} {(conftest.nl)})
                            (command.Simple
                              words: [{(echo)} {(SQ <GREP>)}]
                              redirects: [
                                (redir.Redir
                                  op: <Redir_DGreat '>>'>
                                  fd: 16777215
                                  arg_word: {(conftest.nl)}
                                )
                              ]
                            )
                            (command.AndOr
                              ops: [Op_DPipe]
                              children: [
                                (command.Simple
                                  words: [
                                    {(DQ ($ VSub_DollarName '$_G_path_prog'))}
                                    {(-e)}
                                    {(SQ <'GREP$'>)}
                                    {(-e)}
                                    {(SQ <'-(cannot match)-'>)}
                                  ]
                                  redirects: [
                                    (redir.Redir
                                      op: <Redir_Less '<'>
                                      fd: 16777215
                                      arg_word: {(conftest.nl)}
                                    )
                                    (redir.Redir
                                      op: <Redir_Great '>'>
                                      fd: 16777215
                                      arg_word: {(conftest.out)}
                                    )
                                    (redir.Redir
                                      op: <Redir_Great '2>'>
                                      fd: 2
                                      arg_word: {(/dev/null)}
                                    )
                                  ]
                                )
                                (command.ControlFlow
                                  token: <ControlFlow_Break break>
                                )
                              ]
                            )
                            (command.AndOr
                              ops: [Op_DPipe]
                              children: [
                                (command.Simple
                                  words: [{(diff)} {(conftest.out)} {(conftest.nl)}]
                                  redirects: [
                                    (redir.Redir
                                      op: <Redir_Great '>'>
                                      fd: 16777215
                                      arg_word: {(/dev/null)}
                                    )
                                    (redir.Redir
                                      op: <Redir_GreatAnd '2>&'>
                                      fd: 2
                                      arg_word: {(1)}
                                    )
                                  ]
                                )
                                (command.ControlFlow
                                  token: <ControlFlow_Break break>
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:_G_count)
                                  op: Equal
                                  rhs: 
                                    {
                                      (command_sub
                                        left_token: <Left_Backtick '`'>
                                        command_list: 
                                          (command.CommandList
                                            children: [
                                              (C {(expr)} {($ VSub_DollarName '$_G_count')} 
                                                {(Lit_Other '+')} {(1)}
                                              )
                                            ]
                                          )
                                      )
                                    }
                                )
                              ]
                            )
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (C {(test)} {(DQ ($ VSub_DollarName '$_G_count'))} {(-gt)} 
                                          {(DQ ($ VSub_DollarName '$_G_path_prog_max'))}
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:func_check_prog_result)
                                          op: Equal
                                          rhs: {($ VSub_DollarName '$_G_path_prog')}
                                        )
                                      ]
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:_G_path_prog_max)
                                          op: Equal
                                          rhs: {($ VSub_DollarName '$_G_count')}
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.AndOr
                              ops: [Op_DAmp]
                              children: [
                                (C {(test)} {(10)} {(-lt)} {(DQ ($ VSub_DollarName '$_G_count'))})
                                (command.ControlFlow
                                  token: <ControlFlow_Break break>
                                )
                              ]
                            )
                          ]
                        )
                    )
                    (C {(rm)} {(-f)} {(conftest.in)} {(conftest.tmp)} {(conftest.nl)} {(conftest.out)})
                  ]
                )
            )
            (C {(func_path_progs)} {(DQ ('grep ggrep'))} {(func_check_prog_grep)} 
              {($ VSub_DollarName '$PATH') (Lit_Other ':') (/usr/xpg4/bin)}
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:GREP)
                  op: Equal
                  rhs: {($ VSub_DollarName '$func_path_progs_result')}
                )
              ]
            )
          ]
        )
      ]
    )
    (C {(Lit_Other ':')} 
      {
        (braced_var_sub
          token: <VSub_Name CP>
          suffix_op: (suffix_op.Unary op_id:VTest_Equals arg_word:{(DQ ('cp -f'))})
        )
      }
    )
    (C {(Lit_Other ':')} 
      {
        (braced_var_sub
          token: <VSub_Name ECHO>
          suffix_op: 
            (suffix_op.Unary
              op_id: VTest_Equals
              arg_word: {(DQ ('printf %s') (Lit_Other '\\') (n))}
            )
        )
      }
    )
    (C {(Lit_Other ':')} 
      {
        (braced_var_sub
          token: <VSub_Name EGREP>
          suffix_op: 
            (suffix_op.Unary
              op_id: VTest_Equals
              arg_word: {(DQ ($ VSub_DollarName '$GREP') (' -E'))}
            )
        )
      }
    )
    (C {(Lit_Other ':')} 
      {
        (braced_var_sub
          token: <VSub_Name FGREP>
          suffix_op: 
            (suffix_op.Unary
              op_id: VTest_Equals
              arg_word: {(DQ ($ VSub_DollarName '$GREP') (' -F'))}
            )
        )
      }
    )
    (C {(Lit_Other ':')} 
      {
        (braced_var_sub
          token: <VSub_Name LN_S>
          suffix_op: (suffix_op.Unary op_id:VTest_Equals arg_word:{(DQ ('ln -s'))})
        )
      }
    )
    (C {(Lit_Other ':')} 
      {
        (braced_var_sub
          token: <VSub_Name MAKE>
          suffix_op: (suffix_op.Unary op_id:VTest_Equals arg_word:{(DQ (make))})
        )
      }
    )
    (C {(Lit_Other ':')} 
      {
        (braced_var_sub
          token: <VSub_Name MKDIR>
          suffix_op: (suffix_op.Unary op_id:VTest_Equals arg_word:{(DQ (mkdir))})
        )
      }
    )
    (C {(Lit_Other ':')} 
      {
        (braced_var_sub
          token: <VSub_Name MV>
          suffix_op: (suffix_op.Unary op_id:VTest_Equals arg_word:{(DQ ('mv -f'))})
        )
      }
    )
    (C {(Lit_Other ':')} 
      {
        (braced_var_sub
          token: <VSub_Name RM>
          suffix_op: (suffix_op.Unary op_id:VTest_Equals arg_word:{(DQ ('rm -f'))})
        )
      }
    )
    (C {(Lit_Other ':')} 
      {
        (braced_var_sub
          token: <VSub_Name SHELL>
          suffix_op: 
            (suffix_op.Unary
              op_id: VTest_Equals
              arg_word: 
                {
                  (DQ 
                    (braced_var_sub
                      token: <VSub_Name CONFIG_SHELL>
                      suffix_op: 
                        (suffix_op.Unary
                          op_id: VTest_Hyphen
                          arg_word: {(Lit_Slash /) (bin) (Lit_Slash /) (sh)}
                        )
                    )
                  )
                }
            )
        )
      }
    )
    (command.ShAssignment
      pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:sed_dirname) op:Equal rhs:{(SQ <'s|/[^/]*$||'>)})]
    )
    (command.ShAssignment
      pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:sed_basename) op:Equal rhs:{(SQ <'s|^.*/||'>)})]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:sed_quote_subst)
          op: Equal
          rhs: {(SQ <'s|\\([`"$\\\\]\\)|\\\\\\1|g'>)}
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:sed_double_quote_subst)
          op: Equal
          rhs: {(SQ <'s/\\(["`\\\\]\\)/\\\\\\1/g'>)}
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:sed_make_literal_regex)
          op: Equal
          rhs: {(SQ <'s|[].[^$\\\\*\\/]|\\\\&|g'>)}
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:sed_naive_backslashify)
          op: Equal
          rhs: {(SQ <'s|\\\\\\\\*|\\\\|g;s|/|\\\\|g;s|\\\\|\\\\\\\\|g'>)}
        )
      ]
    )
    (command.ShAssignment
      pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:_G_bs) op:Equal rhs:{(SQ <'\\\\'>)})]
    )
    (command.ShAssignment
      pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:_G_bs2) op:Equal rhs:{(SQ <'\\\\\\\\'>)})]
    )
    (command.ShAssignment
      pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:_G_bs4) op:Equal rhs:{(SQ <'\\\\\\\\\\\\\\\\'>)})]
    )
    (command.ShAssignment
      pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:_G_dollar) op:Equal rhs:{(SQ <'\\$'>)})]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:sed_double_backslash)
          op: Equal
          rhs: 
            {
              (DQ ('  s/') ($ VSub_DollarName '$_G_bs4') ('/&') 
                (word_part.EscapedLiteral token:<Lit_EscapedChar '\\\\'>) ('\n') ('/g\n') ('  s/^') ($ VSub_DollarName '$_G_bs2') ($ VSub_DollarName '$_G_dollar') (/) 
                ($ VSub_DollarName '$_G_bs') ('&/\n') ('  s/') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\\\'>) ('([^') 
                ($ VSub_DollarName '$_G_bs') (']') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\\\'>) (')') ($ VSub_DollarName '$_G_bs2') 
                ($ VSub_DollarName '$_G_dollar') (/) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\\\'>) (1) ($ VSub_DollarName '$_G_bs2') 
                ($ VSub_DollarName '$_G_bs') ($ VSub_DollarName '$_G_dollar') ('/g\n') ('  s/') (Lit_Other '\\') (n//g)
              )
            }
        )
      ]
    )
    (command.ShAssignment
      pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:EXIT_SUCCESS) op:Equal rhs:{(0)})]
    )
    (command.ShAssignment
      pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:EXIT_FAILURE) op:Equal rhs:{(1)})]
    )
    (command.ShAssignment
      pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:EXIT_MISMATCH) op:Equal rhs:{(63)})]
    )
    (command.ShAssignment
      pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:EXIT_SKIP) op:Equal rhs:{(77)})]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:debug_cmd)
          op: Equal
          rhs: 
            {
              (braced_var_sub
                token: <VSub_Name debug_cmd>
                suffix_op: (suffix_op.Unary op_id:VTest_Hyphen arg_word:{(DQ (':'))})
              )
            }
        )
      ]
    )
    (command.ShAssignment
      pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:exit_cmd) op:Equal rhs:{(Lit_Other ':')})]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:exit_status)
          op: Equal
          rhs: {($ VSub_DollarName '$EXIT_SUCCESS')}
        )
      ]
    )
    (command.ShAssignment
      pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:progpath) op:Equal rhs:{($ VSub_Number '$0')})]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:progname)
          op: Equal
          rhs: 
            {
              (command_sub
                left_token: <Left_Backtick '`'>
                command_list: 
                  (command.CommandList
                    children: [
                      (command.Pipeline
                        children: [
                          (C {($ VSub_DollarName '$ECHO')} {(DQ ($ VSub_DollarName '$progpath'))})
                          (C {($ VSub_DollarName '$SED')} {(DQ ($ VSub_DollarName '$sed_basename'))})
                        ]
                        negated: F
                      )
                    ]
                  )
              )
            }
        )
      ]
    )
    (command.Case
      to_match: {($ VSub_DollarName '$progpath')}
      arms: [
        (case_arm
          pat_list: [
            {(Lit_LBracket '[') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\\\'>) (/) 
              (Lit_RBracket ']') (Lit_Star '*')
            }
            {(Lit_LBracket '[') (A-Za-z) (Lit_RBracket ']') (Lit_Other ':') 
              (word_part.EscapedLiteral token:<Lit_EscapedChar '\\\\'>) (Lit_Star '*')
            }
          ]
        )
        (case_arm
          pat_list: [
            {(Lit_Star '*') (Lit_LBracket '[') 
              (word_part.EscapedLiteral token:<Lit_EscapedChar '\\\\'>) (/) (Lit_RBracket ']') (Lit_Star '*')
            }
          ]
          action: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:progdir)
                  op: Equal
                  rhs: 
                    {
                      (command_sub
                        left_token: <Left_Backtick '`'>
                        command_list: 
                          (command.CommandList
                            children: [
                              (command.Pipeline
                                children: [
                                  (C {($ VSub_DollarName '$ECHO')} 
                                    {(DQ ($ VSub_DollarName '$progpath'))}
                                  )
                                  (C {($ VSub_DollarName '$SED')} 
                                    {(DQ ($ VSub_DollarName '$sed_dirname'))}
                                  )
                                ]
                                negated: F
                              )
                            ]
                          )
                      )
                    }
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:progdir)
                  op: Equal
                  rhs: 
                    {
                      (command_sub
                        left_token: <Left_Backtick '`'>
                        command_list: 
                          (command.CommandList
                            children: [
                              (command.AndOr
                                ops: [Op_DAmp]
                                children: [(C {(cd)} {(DQ ($ VSub_DollarName '$progdir'))}) (C {(pwd)})]
                              )
                            ]
                          )
                      )
                    }
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:progpath)
                  op: Equal
                  rhs: {($ VSub_DollarName '$progdir') (/) ($ VSub_DollarName '$progname')}
                )
              ]
            )
          ]
        )
        (case_arm
          pat_list: [{(Lit_Star '*')}]
          action: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:_G_IFS)
                  op: Equal
                  rhs: {($ VSub_DollarName '$IFS')}
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:IFS)
                  op: Equal
                  rhs: 
                    {
                      (braced_var_sub
                        token: <VSub_Name PATH_SEPARATOR>
                        suffix_op: (suffix_op.Unary op_id:VTest_Hyphen arg_word:{(':')})
                      )
                    }
                )
              ]
            )
            (command.ForEach
              iter_name: progdir
              iter_words: [{($ VSub_DollarName '$PATH')}]
              do_arg_iter: F
              body: 
                (command.DoGroup
                  children: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:IFS)
                          op: Equal
                          rhs: {($ VSub_DollarName '$_G_IFS')}
                        )
                      ]
                    )
                    (command.AndOr
                      ops: [Op_DAmp]
                      children: [
                        (C {(test)} {(-x)} 
                          {(DQ ($ VSub_DollarName '$progdir') (/) ($ VSub_DollarName '$progname'))}
                        )
                        (command.ControlFlow token:<ControlFlow_Break break>)
                      ]
                    )
                  ]
                )
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:IFS)
                  op: Equal
                  rhs: {($ VSub_DollarName '$_G_IFS')}
                )
              ]
            )
            (command.AndOr
              ops: [Op_DPipe]
              children: [
                (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$progdir'))})
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:progdir)
                      op: Equal
                      rhs: 
                        {
                          (command_sub
                            left_token: <Left_Backtick '`'>
                            command_list: (command.CommandList children:[(C {(pwd)})])
                          )
                        }
                    )
                  ]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:progpath)
                  op: Equal
                  rhs: {($ VSub_DollarName '$progdir') (/) ($ VSub_DollarName '$progname')}
                )
              ]
            )
          ]
        )
      ]
    )
    (command.ShAssignment
      pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:opt_dry_run) op:Equal rhs:{(false)})]
    )
    (command.ShAssignment
      pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:opt_quiet) op:Equal rhs:{(false)})]
    )
    (command.ShAssignment
      pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:opt_verbose) op:Equal rhs:{(false)})]
    )
    (command.ShAssignment
      pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:warning_categories) op:Equal rhs:(word.Empty))]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:warning_func)
          op: Equal
          rhs: {(func_warn_and_continue)}
        )
      ]
    )
    (command.ShAssignment
      pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:opt_warning_types) op:Equal rhs:{(all)})]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:require_term_colors)
          op: Equal
          rhs: {(func_require_term_colors)}
        )
      ]
    )
    (command.ShFunction
      name: func_require_term_colors
      body: 
        (command.BraceGroup
          children: [
            (C {($ VSub_DollarName '$debug_cmd')})
            (command.AndOr
              ops: [Op_DAmp]
              children: [
                (C {(test)} {(-t)} {(1)})
                (command.BraceGroup
                  children: [
                    (command.AndOr
                      ops: [Op_DAmp]
                      children: [
                        (C {(test)} {(-n)} 
                          {
                            (DQ 
                              (braced_var_sub
                                token: <VSub_Name COLORTERM>
                                suffix_op: (suffix_op.Unary op_id:VTest_Plus arg_word:{(set)})
                              )
                            )
                          }
                        )
                        (C {(Lit_Other ':')} 
                          {
                            (braced_var_sub
                              token: <VSub_Name USE_ANSI_COLORS>
                              suffix_op: (suffix_op.Unary op_id:VTest_Equals arg_word:{(DQ (1))})
                            )
                          }
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: 
                                (C {(test)} {(1)} {(Lit_Equals '=')} 
                                  {(DQ ($ VSub_DollarName '$USE_ANSI_COLORS'))}
                                )
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:tc_reset)
                                  op: Equal
                                  rhs: {(SQ <'\x1b[0m'>)}
                                )
                              ]
                            )
                            (command.Sentence
                              child: 
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:tc_bold)
                                      op: Equal
                                      rhs: {(SQ <'\x1b[1m'>)}
                                    )
                                  ]
                                )
                              terminator: <Op_Semi ';'>
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:tc_standout)
                                  op: Equal
                                  rhs: {(SQ <'\x1b[7m'>)}
                                )
                              ]
                            )
                            (command.Sentence
                              child: 
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:tc_red)
                                      op: Equal
                                      rhs: {(SQ <'\x1b[31m'>)}
                                    )
                                  ]
                                )
                              terminator: <Op_Semi ';'>
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:tc_green)
                                  op: Equal
                                  rhs: {(SQ <'\x1b[32m'>)}
                                )
                              ]
                            )
                            (command.Sentence
                              child: 
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:tc_blue)
                                      op: Equal
                                      rhs: {(SQ <'\x1b[34m'>)}
                                    )
                                  ]
                                )
                              terminator: <Op_Semi ';'>
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:tc_cyan)
                                  op: Equal
                                  rhs: {(SQ <'\x1b[36m'>)}
                                )
                              ]
                            )
                          ]
                        )
                      ]
                      else_action: [
                        (command.AndOr
                          ops: [Op_DAmp]
                          children: [
                            (C {(test)} {(-n)} 
                              {
                                (DQ 
                                  (command_sub
                                    left_token: <Left_Backtick '`'>
                                    command_list: 
                                      (command.CommandList
                                        children: [
                                          (command.Simple
                                            words: [{(tput)} {(sgr0)}]
                                            redirects: [
                                              (redir.Redir
                                                op: <Redir_Great '2>'>
                                                fd: 2
                                                arg_word: {(/dev/null)}
                                              )
                                            ]
                                          )
                                        ]
                                      )
                                  )
                                )
                              }
                            )
                            (command.BraceGroup
                              children: [
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:tc_reset)
                                      op: Equal
                                      rhs: 
                                        {
                                          (command_sub
                                            left_token: <Left_Backtick '`'>
                                            command_list: 
                                              (command.CommandList
                                                children: [(C {(tput)} {(sgr0)})]
                                              )
                                          )
                                        }
                                    )
                                  ]
                                )
                                (command.AndOr
                                  ops: [Op_DAmp]
                                  children: [
                                    (C {(test)} {(-n)} 
                                      {
                                        (DQ 
                                          (command_sub
                                            left_token: <Left_Backtick '`'>
                                            command_list: 
                                              (command.CommandList
                                                children: [
                                                  (command.Simple
                                                    words: [{(tput)} {(bold)}]
                                                    redirects: [
                                                      (redir.Redir
                                                        op: <Redir_Great '2>'>
                                                        fd: 2
                                                        arg_word: {(/dev/null)}
                                                      )
                                                    ]
                                                  )
                                                ]
                                              )
                                          )
                                        )
                                      }
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:tc_bold)
                                          op: Equal
                                          rhs: 
                                            {
                                              (command_sub
                                                left_token: <Left_Backtick '`'>
                                                command_list: 
                                                  (command.CommandList
                                                    children: [(C {(tput)} {(bold)})]
                                                  )
                                              )
                                            }
                                        )
                                      ]
                                    )
                                  ]
                                )
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:tc_standout)
                                      op: Equal
                                      rhs: {($ VSub_DollarName '$tc_bold')}
                                    )
                                  ]
                                )
                                (command.AndOr
                                  ops: [Op_DAmp]
                                  children: [
                                    (C {(test)} {(-n)} 
                                      {
                                        (DQ 
                                          (command_sub
                                            left_token: <Left_Backtick '`'>
                                            command_list: 
                                              (command.CommandList
                                                children: [
                                                  (command.Simple
                                                    words: [{(tput)} {(smso)}]
                                                    redirects: [
                                                      (redir.Redir
                                                        op: <Redir_Great '2>'>
                                                        fd: 2
                                                        arg_word: {(/dev/null)}
                                                      )
                                                    ]
                                                  )
                                                ]
                                              )
                                          )
                                        )
                                      }
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:tc_standout)
                                          op: Equal
                                          rhs: 
                                            {
                                              (command_sub
                                                left_token: <Left_Backtick '`'>
                                                command_list: 
                                                  (command.CommandList
                                                    children: [(C {(tput)} {(smso)})]
                                                  )
                                              )
                                            }
                                        )
                                      ]
                                    )
                                  ]
                                )
                                (command.AndOr
                                  ops: [Op_DAmp]
                                  children: [
                                    (C {(test)} {(-n)} 
                                      {
                                        (DQ 
                                          (command_sub
                                            left_token: <Left_Backtick '`'>
                                            command_list: 
                                              (command.CommandList
                                                children: [
                                                  (command.Simple
                                                    words: [{(tput)} {(setaf)} {(1)}]
                                                    redirects: [
                                                      (redir.Redir
                                                        op: <Redir_Great '2>'>
                                                        fd: 2
                                                        arg_word: {(/dev/null)}
                                                      )
                                                    ]
                                                  )
                                                ]
                                              )
                                          )
                                        )
                                      }
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:tc_red)
                                          op: Equal
                                          rhs: 
                                            {
                                              (command_sub
                                                left_token: <Left_Backtick '`'>
                                                command_list: 
                                                  (command.CommandList
                                                    children: [(C {(tput)} {(setaf)} {(1)})]
                                                  )
                                              )
                                            }
                                        )
                                      ]
                                    )
                                  ]
                                )
                                (command.AndOr
                                  ops: [Op_DAmp]
                                  children: [
                                    (C {(test)} {(-n)} 
                                      {
                                        (DQ 
                                          (command_sub
                                            left_token: <Left_Backtick '`'>
                                            command_list: 
                                              (command.CommandList
                                                children: [
                                                  (command.Simple
                                                    words: [{(tput)} {(setaf)} {(2)}]
                                                    redirects: [
                                                      (redir.Redir
                                                        op: <Redir_Great '2>'>
                                                        fd: 2
                                                        arg_word: {(/dev/null)}
                                                      )
                                                    ]
                                                  )
                                                ]
                                              )
                                          )
                                        )
                                      }
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:tc_green)
                                          op: Equal
                                          rhs: 
                                            {
                                              (command_sub
                                                left_token: <Left_Backtick '`'>
                                                command_list: 
                                                  (command.CommandList
                                                    children: [(C {(tput)} {(setaf)} {(2)})]
                                                  )
                                              )
                                            }
                                        )
                                      ]
                                    )
                                  ]
                                )
                                (command.AndOr
                                  ops: [Op_DAmp]
                                  children: [
                                    (C {(test)} {(-n)} 
                                      {
                                        (DQ 
                                          (command_sub
                                            left_token: <Left_Backtick '`'>
                                            command_list: 
                                              (command.CommandList
                                                children: [
                                                  (command.Simple
                                                    words: [{(tput)} {(setaf)} {(4)}]
                                                    redirects: [
                                                      (redir.Redir
                                                        op: <Redir_Great '2>'>
                                                        fd: 2
                                                        arg_word: {(/dev/null)}
                                                      )
                                                    ]
                                                  )
                                                ]
                                              )
                                          )
                                        )
                                      }
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:tc_blue)
                                          op: Equal
                                          rhs: 
                                            {
                                              (command_sub
                                                left_token: <Left_Backtick '`'>
                                                command_list: 
                                                  (command.CommandList
                                                    children: [(C {(tput)} {(setaf)} {(4)})]
                                                  )
                                              )
                                            }
                                        )
                                      ]
                                    )
                                  ]
                                )
                                (command.AndOr
                                  ops: [Op_DAmp]
                                  children: [
                                    (C {(test)} {(-n)} 
                                      {
                                        (DQ 
                                          (command_sub
                                            left_token: <Left_Backtick '`'>
                                            command_list: 
                                              (command.CommandList
                                                children: [
                                                  (command.Simple
                                                    words: [{(tput)} {(setaf)} {(5)}]
                                                    redirects: [
                                                      (redir.Redir
                                                        op: <Redir_Great '2>'>
                                                        fd: 2
                                                        arg_word: {(/dev/null)}
                                                      )
                                                    ]
                                                  )
                                                ]
                                              )
                                          )
                                        )
                                      }
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:tc_cyan)
                                          op: Equal
                                          rhs: 
                                            {
                                              (command_sub
                                                left_token: <Left_Backtick '`'>
                                                command_list: 
                                                  (command.CommandList
                                                    children: [(C {(tput)} {(setaf)} {(5)})]
                                                  )
                                              )
                                            }
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                            )
                          ]
                        )
                      ]
                    )
                  ]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:require_term_colors)
                  op: Equal
                  rhs: {(Lit_Other ':')}
                )
              ]
            )
          ]
        )
    )
    (command.If
      arms: [
        (if_arm
          cond: [
            (command.Sentence
              child: 
                (C {(test)} {(KW_Set set)} {(Lit_Equals '=')} 
                  {
                    (DQ 
                      (braced_var_sub
                        token: <VSub_Name BASH_VERSION>
                        suffix_op: (suffix_op.Unary op_id:VTest_Plus arg_word:{(set)})
                      ) 
                      (braced_var_sub
                        token: <VSub_Name ZSH_VERSION>
                        suffix_op: (suffix_op.Unary op_id:VTest_Plus arg_word:{(set)})
                      )
                    )
                  }
                )
              terminator: <Op_Semi ';'>
            )
          ]
          action: [
            (C {(Lit_Other ':')} 
              {
                (braced_var_sub
                  token: <VSub_Name _G_HAVE_ARITH_OP>
                  suffix_op: (suffix_op.Unary op_id:VTest_Equals arg_word:{(DQ (yes))})
                )
              }
            )
            (C {(Lit_Other ':')} 
              {
                (braced_var_sub
                  token: <VSub_Name _G_HAVE_XSI_OPS>
                  suffix_op: (suffix_op.Unary op_id:VTest_Equals arg_word:{(DQ (yes))})
                )
              }
            )
            (command.Case
              to_match: {($ VSub_DollarName '$BASH_VERSION')}
              arms: [
                (case_arm
                  pat_list: [
                    {(Lit_LBracket '[') (12) (Lit_RBracket ']') (.) (Lit_Star '*')}
                    {(3.0)}
                    {(3.0) (Lit_Star '*')}
                  ]
                )
                (case_arm
                  pat_list: [{(Lit_Star '*')}]
                  action: [
                    (C {(Lit_Other ':')} 
                      {
                        (braced_var_sub
                          token: <VSub_Name _G_HAVE_PLUSEQ_OP>
                          suffix_op: (suffix_op.Unary op_id:VTest_Equals arg_word:{(DQ (yes))})
                        )
                      }
                    )
                  ]
                )
              ]
            )
          ]
        )
      ]
    )
    (command.AndOr
      ops: [Op_DAmp Op_DAmp]
      children: [
        (C {(test)} {(-z)} {(DQ ($ VSub_DollarName '$_G_HAVE_PLUSEQ_OP'))})
        (command.Subshell
          command_list: 
            (command.CommandList
              children: [(C {(eval)} {(SQ <'x=a; x+=" b"; test "a b" = "$x"'>)})]
            )
          redirects: [(redir.Redir op:<Redir_Great '2>'> fd:2 arg_word:{(/dev/null)})]
        )
        (command.ShAssignment
          pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:_G_HAVE_PLUSEQ_OP) op:Equal rhs:{(yes)})]
        )
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: [(C {(test)} {(yes)} {(Lit_Equals '=')} {(DQ ($ VSub_DollarName '$_G_HAVE_PLUSEQ_OP'))})]
          action: [
            (C {(eval)} 
              {
                (SQ <'func_append ()\n'> <'  {\n'> <'    $debug_cmd\n'> <'\n'> <'    eval "$1+=\\$2"\n'> 
                  <'  }'>
                )
              }
            )
          ]
        )
      ]
      else_action: [
        (command.ShFunction
          name: func_append
          body: 
            (command.BraceGroup
              children: [
                (C {($ VSub_DollarName '$debug_cmd')})
                (C {(eval)} 
                  {
                    (DQ ($ VSub_Number '$1') ('=') 
                      (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) ($ VSub_Number '$1') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) (2)
                    )
                  }
                )
              ]
            )
        )
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: [
            (command.Sentence
              child: 
                (C {(test)} {(yes)} {(Lit_Equals '=')} {(DQ ($ VSub_DollarName '$_G_HAVE_PLUSEQ_OP'))})
              terminator: <Op_Semi ';'>
            )
          ]
          action: [
            (C {(eval)} 
              {
                (SQ <'func_append_quoted ()\n'> <'  {\n'> <'    $debug_cmd\n'> <'\n'> 
                  <'    func_quote_for_eval "$2"\n'> <'    eval "$1+=\\\\ \\$func_quote_for_eval_result"\n'> <'  }'>
                )
              }
            )
          ]
        )
      ]
      else_action: [
        (command.ShFunction
          name: func_append_quoted
          body: 
            (command.BraceGroup
              children: [
                (C {($ VSub_DollarName '$debug_cmd')})
                (C {(func_quote_for_eval)} {(DQ ($ VSub_Number '$2'))})
                (C {(eval)} 
                  {
                    (DQ ($ VSub_Number '$1') ('=') 
                      (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) ($ VSub_Number '$1') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\\\'>) (' ') 
                      (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) (func_quote_for_eval_result)
                    )
                  }
                )
              ]
            )
        )
      ]
    )
    (command.ShFunction
      name: func_append_uniq
      body: 
        (command.BraceGroup
          children: [
            (C {($ VSub_DollarName '$debug_cmd')})
            (C {(eval)} 
              {(Lit_VarLike '_G_current_value=') (SQ <'`$ECHO $'>) ($ VSub_Number '$1') (SQ <'`'>)}
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:_G_delim)
                  op: Equal
                  rhs: 
                    {
                      (command_sub
                        left_token: <Left_Backtick '`'>
                        command_list: 
                          (command.CommandList
                            children: [
                              (C {(expr)} {(DQ ($ VSub_Number '$2'))} {(Lit_Other ':')} {(SQ <'\\(.\\)'>)})
                            ]
                          )
                      )
                    }
                )
              ]
            )
            (command.Case
              to_match: 
                {($ VSub_DollarName '$_G_delim') ($ VSub_DollarName '$_G_current_value') 
                  ($ VSub_DollarName '$_G_delim')
                }
              arms: [
                (case_arm
                  pat_list: [
                    {(Lit_Star '*') (DQ ($ VSub_Number '$2') ($ VSub_DollarName '$_G_delim')) 
                      (Lit_Star '*')
                    }
                  ]
                )
                (case_arm
                  pat_list: [{(Lit_Star '*')}]
                  action: [(C {(func_append)} {(DQ ($ VSub_At '$@'))})]
                )
              ]
            )
          ]
        )
    )
    (command.AndOr
      ops: [Op_DAmp Op_DAmp]
      children: [
        (C {(test)} {(-z)} {(DQ ($ VSub_DollarName '$_G_HAVE_ARITH_OP'))})
        (command.Subshell
          command_list: 
            (command.CommandList
              children: [(C {(eval)} {(SQ <'test 2 = $(( 1 + 1 ))'>)})]
            )
          redirects: [(redir.Redir op:<Redir_Great '2>'> fd:2 arg_word:{(/dev/null)})]
        )
        (command.ShAssignment
          pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:_G_HAVE_ARITH_OP) op:Equal rhs:{(yes)})]
        )
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: [
            (command.Sentence
              child: 
                (C {(test)} {(yes)} {(Lit_Equals '=')} {(DQ ($ VSub_DollarName '$_G_HAVE_ARITH_OP'))})
              terminator: <Op_Semi ';'>
            )
          ]
          action: [
            (C {(eval)} 
              {
                (SQ <'func_arith ()\n'> <'  {\n'> <'    $debug_cmd\n'> <'\n'> 
                  <'    func_arith_result=$(( $* ))\n'> <'  }'>
                )
              }
            )
          ]
        )
      ]
      else_action: [
        (command.ShFunction
          name: func_arith
          body: 
            (command.BraceGroup
              children: [
                (C {($ VSub_DollarName '$debug_cmd')})
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:func_arith_result)
                      op: Equal
                      rhs: 
                        {
                          (command_sub
                            left_token: <Left_Backtick '`'>
                            command_list: 
                              (command.CommandList
                                children: [(C {(expr)} {(DQ ($ VSub_At '$@'))})]
                              )
                          )
                        }
                    )
                  ]
                )
              ]
            )
        )
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: [
            (command.Sentence
              child: 
                (C {(test)} {(yes)} {(Lit_Equals '=')} {(DQ ($ VSub_DollarName '$_G_HAVE_XSI_OPS'))})
              terminator: <Op_Semi ';'>
            )
          ]
          action: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:_b)
                  op: Equal
                  rhs: {(SQ <'func_basename_result=${1##*/}'>)}
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:_d)
                  op: Equal
                  rhs: 
                    {
                      (SQ <'case $1 in\n'> <'        */*) func_dirname_result=${1%/*}$2 ;;\n'> 
                        <'        *  ) func_dirname_result=$3        ;;\n'> <'      esac'>
                      )
                    }
                )
              ]
            )
          ]
        )
      ]
      else_action: [
        (command.ShAssignment
          pairs: [
            (assign_pair
              lhs: (sh_lhs_expr.Name name:_b)
              op: Equal
              rhs: {(SQ <'func_basename_result=`$ECHO "$1" |$SED "$sed_basename"`'>)}
            )
          ]
        )
        (command.ShAssignment
          pairs: [
            (assign_pair
              lhs: (sh_lhs_expr.Name name:_d)
              op: Equal
              rhs: 
                {
                  (SQ <'func_dirname_result=`$ECHO "$1"  |$SED "$sed_dirname"`\n'> 
                    <'      if test "X$func_dirname_result" = "X$1"; then\n'> <'        func_dirname_result=$3\n'> <'      else\n'> 
                    <'        func_append func_dirname_result "$2"\n'> <'      fi'>
                  )
                }
            )
          ]
        )
      ]
    )
    (C {(eval)} 
      {(SQ <'func_basename ()\n'> <'{\n'> <'    $debug_cmd\n'> <'\n'> <'    '>) 
        (DQ ($ VSub_DollarName '$_b')) (SQ <'\n'> <'}'>)
      }
    )
    (C {(eval)} 
      {(SQ <'func_dirname ()\n'> <'{\n'> <'    $debug_cmd\n'> <'\n'> <'    '>) 
        (DQ ($ VSub_DollarName '$_d')) (SQ <'\n'> <'}'>)
      }
    )
    (C {(eval)} 
      {(SQ <'func_dirname_and_basename ()\n'> <'{\n'> <'    $debug_cmd\n'> <'\n'> <'    '>) 
        (DQ ($ VSub_DollarName '$_b')) (SQ <'\n'> <'    '>) (DQ ($ VSub_DollarName '$_d')) (SQ <'\n'> <'}'>)
      }
    )
    (command.ShFunction
      name: func_echo
      body: 
        (command.BraceGroup
          children: [
            (C {($ VSub_DollarName '$debug_cmd')})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:_G_message)
                  op: Equal
                  rhs: {($ VSub_Star '$*')}
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:func_echo_IFS)
                  op: Equal
                  rhs: {($ VSub_DollarName '$IFS')}
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:IFS)
                  op: Equal
                  rhs: {($ VSub_DollarName '$nl')}
                )
              ]
            )
            (command.ForEach
              iter_name: _G_line
              iter_words: [{($ VSub_DollarName '$_G_message')}]
              do_arg_iter: F
              body: 
                (command.DoGroup
                  children: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:IFS)
                          op: Equal
                          rhs: {($ VSub_DollarName '$func_echo_IFS')}
                        )
                      ]
                    )
                    (C {($ VSub_DollarName '$ECHO')} 
                      {(DQ ($ VSub_DollarName '$progname') (': ') ($ VSub_DollarName '$_G_line'))}
                    )
                  ]
                )
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:IFS)
                  op: Equal
                  rhs: {($ VSub_DollarName '$func_echo_IFS')}
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: func_echo_all
      body: 
        (command.BraceGroup
          children: [(C {($ VSub_DollarName '$ECHO')} {(DQ ($ VSub_Star '$*'))})]
        )
    )
    (command.ShFunction
      name: func_echo_infix_1
      body: 
        (command.BraceGroup
          children: [
            (C {($ VSub_DollarName '$debug_cmd')})
            (C {($ VSub_DollarName '$require_term_colors')})
            (command.Sentence
              child: 
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:_G_infix)
                      op: Equal
                      rhs: {($ VSub_Number '$1')}
                    )
                  ]
                )
              terminator: <Op_Semi ';'>
            )
            (C {(shift)})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:_G_indent)
                  op: Equal
                  rhs: {($ VSub_DollarName '$_G_infix')}
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:_G_prefix)
                  op: Equal
                  rhs: 
                    {
                      (DQ ($ VSub_DollarName '$progname') (': ') ($ VSub_DollarName '$_G_infix') (': '))
                    }
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:_G_message)
                  op: Equal
                  rhs: {($ VSub_Star '$*')}
                )
              ]
            )
            (command.ForEach
              iter_name: _G_tc
              iter_words: [
                {(DQ ($ VSub_DollarName '$tc_reset'))}
                {(DQ ($ VSub_DollarName '$tc_bold'))}
                {(DQ ($ VSub_DollarName '$tc_standout'))}
                {(DQ ($ VSub_DollarName '$tc_red'))}
                {(DQ ($ VSub_DollarName '$tc_green'))}
                {(DQ ($ VSub_DollarName '$tc_blue'))}
                {(DQ ($ VSub_DollarName '$tc_cyan'))}
              ]
              do_arg_iter: F
              body: 
                (command.DoGroup
                  children: [
                    (command.AndOr
                      ops: [Op_DAmp]
                      children: [
                        (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$_G_tc'))})
                        (command.BraceGroup
                          children: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:_G_esc_tc)
                                  op: Equal
                                  rhs: 
                                    {
                                      (command_sub
                                        left_token: <Left_Backtick '`'>
                                        command_list: 
                                          (command.CommandList
                                            children: [
                                              (command.Pipeline
                                                children: [
                                                  (C {($ VSub_DollarName '$ECHO')} 
                                                    {(DQ ($ VSub_DollarName '$_G_tc'))}
                                                  )
                                                  (C {($ VSub_DollarName '$SED')} 
                                                    {
                                                      (DQ 
                                                        ($ VSub_DollarName '$sed_make_literal_regex')
                                                      )
                                                    }
                                                  )
                                                ]
                                                negated: F
                                              )
                                            ]
                                          )
                                      )
                                    }
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:_G_indent)
                                  op: Equal
                                  rhs: 
                                    {
                                      (command_sub
                                        left_token: <Left_Backtick '`'>
                                        command_list: 
                                          (command.CommandList
                                            children: [
                                              (command.Pipeline
                                                children: [
                                                  (C {($ VSub_DollarName '$ECHO')} 
                                                    {(DQ ($ VSub_DollarName '$_G_indent'))}
                                                  )
                                                  (C {($ VSub_DollarName '$SED')} 
                                                    {
                                                      (DQ ('s|') ($ VSub_DollarName '$_G_esc_tc') 
                                                        ('||g')
                                                      )
                                                    }
                                                  )
                                                ]
                                                negated: F
                                              )
                                            ]
                                          )
                                      )
                                    }
                                )
                              ]
                            )
                          ]
                        )
                      ]
                    )
                  ]
                )
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:_G_indent)
                  op: Equal
                  rhs: 
                    {(DQ ($ VSub_DollarName '$progname') (': ')) 
                      (command_sub
                        left_token: <Left_Backtick '`'>
                        command_list: 
                          (command.CommandList
                            children: [
                              (command.Pipeline
                                children: [
                                  (C {(echo)} {(DQ ($ VSub_DollarName '$_G_indent'))})
                                  (C {($ VSub_DollarName '$SED')} {(SQ <'s|.| |g'>)})
                                ]
                                negated: F
                              )
                            ]
                          )
                      ) (DQ ('  '))
                    }
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:func_echo_infix_1_IFS)
                  op: Equal
                  rhs: {($ VSub_DollarName '$IFS')}
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:IFS)
                  op: Equal
                  rhs: {($ VSub_DollarName '$nl')}
                )
              ]
            )
            (command.ForEach
              iter_name: _G_line
              iter_words: [{($ VSub_DollarName '$_G_message')}]
              do_arg_iter: F
              body: 
                (command.DoGroup
                  children: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:IFS)
                          op: Equal
                          rhs: {($ VSub_DollarName '$func_echo_infix_1_IFS')}
                        )
                      ]
                    )
                    (command.Simple
                      words: [
                        {($ VSub_DollarName '$ECHO')}
                        {
                          (DQ ($ VSub_DollarName '$_G_prefix') ($ VSub_DollarName '$tc_bold') 
                            ($ VSub_DollarName '$_G_line') ($ VSub_DollarName '$tc_reset')
                          )
                        }
                      ]
                      redirects: [(redir.Redir op:<Redir_GreatAnd '>&'> fd:16777215 arg_word:{(2)})]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:_G_prefix)
                          op: Equal
                          rhs: {($ VSub_DollarName '$_G_indent')}
                        )
                      ]
                    )
                  ]
                )
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:IFS)
                  op: Equal
                  rhs: {($ VSub_DollarName '$func_echo_infix_1_IFS')}
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: func_error
      body: 
        (command.BraceGroup
          children: [
            (C {($ VSub_DollarName '$debug_cmd')})
            (C {($ VSub_DollarName '$require_term_colors')})
            (command.Simple
              words: [
                {(func_echo_infix_1)}
                {
                  (DQ ('  ') ($ VSub_DollarName '$tc_standout') (${ VSub_Name tc_red) (error) 
                    ($ VSub_DollarName '$tc_reset')
                  )
                }
                {(DQ ($ VSub_Star '$*'))}
              ]
              redirects: [(redir.Redir op:<Redir_GreatAnd '>&'> fd:16777215 arg_word:{(2)})]
            )
          ]
        )
    )
    (command.ShFunction
      name: func_fatal_error
      body: 
        (command.BraceGroup
          children: [
            (C {($ VSub_DollarName '$debug_cmd')})
            (C {(func_error)} {(DQ ($ VSub_Star '$*'))})
            (command.ControlFlow
              token: <ControlFlow_Exit exit>
              arg_word: {($ VSub_DollarName '$EXIT_FAILURE')}
            )
          ]
        )
    )
    (command.ShFunction
      name: func_grep
      body: 
        (command.BraceGroup
          children: [
            (C {($ VSub_DollarName '$debug_cmd')})
            (command.Simple
              words: [
                {($ VSub_DollarName '$GREP')}
                {(DQ ($ VSub_Number '$1'))}
                {(DQ ($ VSub_Number '$2'))}
              ]
              redirects: [
                (redir.Redir op:<Redir_Great '>'> fd:16777215 arg_word:{(/dev/null)})
                (redir.Redir op:<Redir_GreatAnd '2>&'> fd:2 arg_word:{(1)})
              ]
            )
          ]
        )
    )
    (command.AndOr
      ops: [Op_DAmp Op_DAmp]
      children: [
        (C {(test)} {(-z)} {(DQ ($ VSub_DollarName '$_G_HAVE_XSI_OPS'))})
        (command.Subshell
          command_list: 
            (command.CommandList
              children: [
                (C {(eval)} 
                  {
                    (SQ <'x=a/b/c;\n'> 
                      <'      test 5aa/bb/cc = "${#x}${x%%/*}${x%/*}${x#*/}${x##*/}"'>
                    )
                  }
                )
              ]
            )
          redirects: [(redir.Redir op:<Redir_Great '2>'> fd:2 arg_word:{(/dev/null)})]
        )
        (command.ShAssignment
          pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:_G_HAVE_XSI_OPS) op:Equal rhs:{(yes)})]
        )
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: [
            (command.Sentence
              child: 
                (C {(test)} {(yes)} {(Lit_Equals '=')} {(DQ ($ VSub_DollarName '$_G_HAVE_XSI_OPS'))})
              terminator: <Op_Semi ';'>
            )
          ]
          action: [
            (C {(eval)} 
              {
                (SQ <'func_len ()\n'> <'  {\n'> <'    $debug_cmd\n'> <'\n'> 
                  <'    func_len_result=${#1}\n'> <'  }'>
                )
              }
            )
          ]
        )
      ]
      else_action: [
        (command.ShFunction
          name: func_len
          body: 
            (command.BraceGroup
              children: [
                (C {($ VSub_DollarName '$debug_cmd')})
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:func_len_result)
                      op: Equal
                      rhs: 
                        {
                          (command_sub
                            left_token: <Left_Backtick '`'>
                            command_list: 
                              (command.CommandList
                                children: [
                                  (command.AndOr
                                    ops: [Op_DPipe]
                                    children: [
                                      (command.Simple
                                        words: [
                                          {(expr)}
                                          {(DQ ($ VSub_Number '$1'))}
                                          {(Lit_Other ':')}
                                          {(DQ ('.*'))}
                                        ]
                                        redirects: [
                                          (redir.Redir
                                            op: <Redir_Great '2>'>
                                            fd: 2
                                            arg_word: {(/dev/null)}
                                          )
                                        ]
                                      )
                                      (C {(echo)} {($ VSub_DollarName '$max_cmd_len')})
                                    ]
                                  )
                                ]
                              )
                          )
                        }
                    )
                  ]
                )
              ]
            )
        )
      ]
    )
    (command.ShFunction
      name: func_mkdir_p
      body: 
        (command.BraceGroup
          children: [
            (C {($ VSub_DollarName '$debug_cmd')})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:_G_directory_path)
                  op: Equal
                  rhs: {($ VSub_Number '$1')}
                )
              ]
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:_G_dir_list) op:Equal rhs:(word.Empty))]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: 
                        (command.AndOr
                          ops: [Op_DAmp]
                          children: [
                            (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$_G_directory_path'))})
                            (C {(test)} {(Lit_Other ':')} {(KW_Bang '!') (Lit_Equals '=')} 
                              {(DQ ($ VSub_DollarName '$opt_dry_run'))}
                            )
                          ]
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (command.Case
                      to_match: {($ VSub_DollarName '$_G_directory_path')}
                      arms: [
                        (case_arm
                          pat_list: [{(-) (Lit_Star '*')}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:_G_directory_path)
                                  op: Equal
                                  rhs: {(./) ($ VSub_DollarName '$_G_directory_path')}
                                )
                              ]
                            )
                          ]
                        )
                      ]
                    )
                    (command.WhileUntil
                      keyword: <KW_While while>
                      cond: [
                        (command.Sentence
                          child: 
                            (C {(test)} {(KW_Bang '!')} {(-d)} 
                              {(DQ ($ VSub_DollarName '$_G_directory_path'))}
                            )
                          terminator: <Op_Semi ';'>
                        )
                      ]
                      body: 
                        (command.DoGroup
                          children: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:_G_dir_list)
                                  op: Equal
                                  rhs: 
                                    {($ VSub_DollarName '$_G_directory_path') (Lit_Other ':') 
                                      ($ VSub_DollarName '$_G_dir_list')
                                    }
                                )
                              ]
                            )
                            (command.Case
                              to_match: {($ VSub_DollarName '$_G_directory_path')}
                              arms: [
                                (case_arm
                                  pat_list: [{(Lit_Star '*') (/) (Lit_Star '*')}]
                                )
                                (case_arm
                                  pat_list: [{(Lit_Star '*')}]
                                  action: [(command.ControlFlow token:<ControlFlow_Break break>)]
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:_G_directory_path)
                                  op: Equal
                                  rhs: 
                                    {
                                      (command_sub
                                        left_token: <Left_Backtick '`'>
                                        command_list: 
                                          (command.CommandList
                                            children: [
                                              (command.Pipeline
                                                children: [
                                                  (C {($ VSub_DollarName '$ECHO')} 
                                                    {(DQ ($ VSub_DollarName '$_G_directory_path'))}
                                                  )
                                                  (C {($ VSub_DollarName '$SED')} {(-e)} 
                                                    {(DQ ($ VSub_DollarName '$sed_dirname'))}
                                                  )
                                                ]
                                                negated: F
                                              )
                                            ]
                                          )
                                      )
                                    }
                                )
                              ]
                            )
                          ]
                        )
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:_G_dir_list)
                          op: Equal
                          rhs: 
                            {
                              (command_sub
                                left_token: <Left_Backtick '`'>
                                command_list: 
                                  (command.CommandList
                                    children: [
                                      (command.Pipeline
                                        children: [
                                          (C {($ VSub_DollarName '$ECHO')} 
                                            {(DQ ($ VSub_DollarName '$_G_dir_list'))}
                                          )
                                          (C {($ VSub_DollarName '$SED')} {(SQ <'s|:*$||'>)})
                                        ]
                                        negated: F
                                      )
                                    ]
                                  )
                              )
                            }
                        )
                      ]
                    )
                    (command.Sentence
                      child: 
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:func_mkdir_p_IFS)
                              op: Equal
                              rhs: {($ VSub_DollarName '$IFS')}
                            )
                          ]
                        )
                      terminator: <Op_Semi ';'>
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:IFS)
                          op: Equal
                          rhs: {(Lit_Other ':')}
                        )
                      ]
                    )
                    (command.ForEach
                      iter_name: _G_dir
                      iter_words: [{($ VSub_DollarName '$_G_dir_list')}]
                      do_arg_iter: F
                      body: 
                        (command.DoGroup
                          children: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:IFS)
                                  op: Equal
                                  rhs: {($ VSub_DollarName '$func_mkdir_p_IFS')}
                                )
                              ]
                            )
                            (command.AndOr
                              ops: [Op_DPipe]
                              children: [
                                (command.Simple
                                  words: [
                                    {($ VSub_DollarName '$MKDIR')}
                                    {(DQ ($ VSub_DollarName '$_G_dir'))}
                                  ]
                                  redirects: [
                                    (redir.Redir
                                      op: <Redir_Great '2>'>
                                      fd: 2
                                      arg_word: {(/dev/null)}
                                    )
                                  ]
                                )
                                (C {(Lit_Other ':')})
                              ]
                            )
                          ]
                        )
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:IFS)
                          op: Equal
                          rhs: {($ VSub_DollarName '$func_mkdir_p_IFS')}
                        )
                      ]
                    )
                    (command.AndOr
                      ops: [Op_DPipe]
                      children: [
                        (C {(test)} {(-d)} {(DQ ($ VSub_DollarName '$_G_directory_path'))})
                        (C {(func_fatal_error)} {(DQ ("Failed to create '") ($ VSub_Number '$1') ("'"))})
                      ]
                    )
                  ]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: func_mktempdir
      body: 
        (command.BraceGroup
          children: [
            (C {($ VSub_DollarName '$debug_cmd')})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:_G_template)
                  op: Equal
                  rhs: 
                    {
                      (braced_var_sub
                        token: <VSub_Name TMPDIR>
                        suffix_op: (suffix_op.Unary op_id:VTest_Hyphen arg_word:{(Lit_Slash /) (tmp)})
                      ) (/) 
                      (braced_var_sub
                        token: <VSub_Number 1>
                        suffix_op: 
                          (suffix_op.Unary
                            op_id: VTest_Hyphen
                            arg_word: {($ VSub_DollarName '$progname')}
                          )
                      )
                    }
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: 
                        (C {(test)} {(Lit_Other ':')} {(Lit_Equals '=')} 
                          {(DQ ($ VSub_DollarName '$opt_dry_run'))}
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:_G_tmpdir)
                          op: Equal
                          rhs: {($ VSub_DollarName '$_G_template') (-) ($ VSub_Dollar '$$')}
                        )
                      ]
                    )
                  ]
                )
              ]
              else_action: [
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:_G_tmpdir)
                      op: Equal
                      rhs: 
                        {
                          (command_sub
                            left_token: <Left_Backtick '`'>
                            command_list: 
                              (command.CommandList
                                children: [
                                  (command.Simple
                                    words: [
                                      {(mktemp)}
                                      {(-d)}
                                      {(DQ ($ VSub_DollarName '$_G_template') (-XXXXXXXX))}
                                    ]
                                    redirects: [
                                      (redir.Redir
                                        op: <Redir_Great '2>'>
                                        fd: 2
                                        arg_word: {(/dev/null)}
                                      )
                                    ]
                                  )
                                ]
                              )
                          )
                        }
                    )
                  ]
                )
                (command.If
                  arms: [
                    (if_arm
                      cond: [
                        (command.Sentence
                          child: 
                            (C {(test)} {(KW_Bang '!')} {(-d)} {(DQ ($ VSub_DollarName '$_G_tmpdir'))})
                          terminator: <Op_Semi ';'>
                        )
                      ]
                      action: [
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:_G_tmpdir)
                              op: Equal
                              rhs: 
                                {($ VSub_DollarName '$_G_template') (-) 
                                  (braced_var_sub
                                    token: <VSub_Name RANDOM>
                                    suffix_op: (suffix_op.Unary op_id:VTest_Hyphen arg_word:{(0)})
                                  ) ($ VSub_Dollar '$$')
                                }
                            )
                          ]
                        )
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:func_mktempdir_umask)
                              op: Equal
                              rhs: 
                                {
                                  (command_sub
                                    left_token: <Left_Backtick '`'>
                                    command_list: (command.CommandList children:[(C {(umask)})])
                                  )
                                }
                            )
                          ]
                        )
                        (C {(umask)} {(0077)})
                        (C {($ VSub_DollarName '$MKDIR')} {(DQ ($ VSub_DollarName '$_G_tmpdir'))})
                        (C {(umask)} {($ VSub_DollarName '$func_mktempdir_umask')})
                      ]
                    )
                  ]
                )
                (command.AndOr
                  ops: [Op_DPipe]
                  children: [
                    (C {(test)} {(-d)} {(DQ ($ VSub_DollarName '$_G_tmpdir'))})
                    (C {(func_fatal_error)} 
                      {
                        (DQ ("cannot create temporary directory '") ($ VSub_DollarName '$_G_tmpdir') 
                          ("'")
                        )
                      }
                    )
                  ]
                )
              ]
            )
            (C {($ VSub_DollarName '$ECHO')} {(DQ ($ VSub_DollarName '$_G_tmpdir'))})
          ]
        )
    )
    (command.ShFunction
      name: func_normal_abspath
      body: 
        (command.BraceGroup
          children: [
            (C {($ VSub_DollarName '$debug_cmd')})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:_G_pathcar)
                  op: Equal
                  rhs: {(SQ <'s|^/\\([^/]*\\).*$|\\1|'>)}
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:_G_pathcdr)
                  op: Equal
                  rhs: {(SQ <'s|^/[^/]*||'>)}
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:_G_removedotparts)
                  op: Equal
                  rhs: {(SQ <':dotsl\n'> <'\t\ts|/\\./|/|g\n'> <'\t\tt dotsl\n'> <'\t\ts|/\\.$|/|'>)}
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:_G_collapseslashes)
                  op: Equal
                  rhs: {(SQ <'s|/\\{1,\\}|/|g'>)}
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:_G_finalslash)
                  op: Equal
                  rhs: {(SQ <'s|/*$|/|'>)}
                )
              ]
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:func_normal_abspath_result) op:Equal rhs:(word.Empty))]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:func_normal_abspath_tpath)
                  op: Equal
                  rhs: {($ VSub_Number '$1')}
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:func_normal_abspath_altnamespace)
                  op: Equal
                  rhs: (word.Empty)
                )
              ]
            )
            (command.Case
              to_match: {($ VSub_DollarName '$func_normal_abspath_tpath')}
              arms: [
                (case_arm
                  pat_list: [{(DQ )}]
                  action: [
                    (C {(func_stripname)} {(SQ )} {(SQ </>)} 
                      {
                        (DQ 
                          (command_sub
                            left_token: <Left_Backtick '`'>
                            command_list: (command.CommandList children:[(C {(pwd)})])
                          )
                        )
                      }
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:func_normal_abspath_result)
                          op: Equal
                          rhs: {($ VSub_DollarName '$func_stripname_result')}
                        )
                      ]
                    )
                    (command.ControlFlow token:<ControlFlow_Return return>)
                  ]
                )
                (case_arm pat_list:[{(///) (Lit_Star '*')}])
                (case_arm
                  pat_list: [{(//) (Lit_Star '*')}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:func_normal_abspath_altnamespace)
                          op: Equal
                          rhs: {(/)}
                        )
                      ]
                    )
                  ]
                )
                (case_arm pat_list:[{(/) (Lit_Star '*')}])
                (case_arm
                  pat_list: [{(Lit_Star '*')}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:func_normal_abspath_tpath)
                          op: Equal
                          rhs: 
                            {
                              (command_sub
                                left_token: <Left_Backtick '`'>
                                command_list: (command.CommandList children:[(C {(pwd)})])
                              ) (/) ($ VSub_DollarName '$func_normal_abspath_tpath')
                            }
                        )
                      ]
                    )
                  ]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:func_normal_abspath_tpath)
                  op: Equal
                  rhs: 
                    {
                      (command_sub
                        left_token: <Left_Backtick '`'>
                        command_list: 
                          (command.CommandList
                            children: [
                              (command.Pipeline
                                children: [
                                  (C {($ VSub_DollarName '$ECHO')} 
                                    {(DQ ($ VSub_DollarName '$func_normal_abspath_tpath'))}
                                  )
                                  (C {($ VSub_DollarName '$SED')} {(-e)} 
                                    {(DQ ($ VSub_DollarName '$_G_removedotparts'))} {(-e)} {(DQ ($ VSub_DollarName '$_G_collapseslashes'))} {(-e)} {(DQ ($ VSub_DollarName '$_G_finalslash'))}
                                  )
                                ]
                                negated: F
                              )
                            ]
                          )
                      )
                    }
                )
              ]
            )
            (command.WhileUntil
              keyword: <KW_While while>
              cond: [(command.Sentence child:(C {(Lit_Other ':')}) terminator:<Op_Semi ';'>)]
              body: 
                (command.DoGroup
                  children: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: 
                                (C {(test)} {(/)} {(Lit_Equals '=')} 
                                  {(DQ ($ VSub_DollarName '$func_normal_abspath_tpath'))}
                                )
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (C {(test)} {(-z)} 
                                          {(DQ ($ VSub_DollarName '$func_normal_abspath_result'))}
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:func_normal_abspath_result)
                                          op: Equal
                                          rhs: {(/)}
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.ControlFlow
                              token: <ControlFlow_Break break>
                            )
                          ]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:func_normal_abspath_tcomponent)
                          op: Equal
                          rhs: 
                            {
                              (command_sub
                                left_token: <Left_Backtick '`'>
                                command_list: 
                                  (command.CommandList
                                    children: [
                                      (command.Pipeline
                                        children: [
                                          (C {($ VSub_DollarName '$ECHO')} 
                                            {(DQ ($ VSub_DollarName '$func_normal_abspath_tpath'))}
                                          )
                                          (C {($ VSub_DollarName '$SED')} {(-e)} 
                                            {(DQ ($ VSub_DollarName '$_G_pathcar'))}
                                          )
                                        ]
                                        negated: F
                                      )
                                    ]
                                  )
                              )
                            }
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:func_normal_abspath_tpath)
                          op: Equal
                          rhs: 
                            {
                              (command_sub
                                left_token: <Left_Backtick '`'>
                                command_list: 
                                  (command.CommandList
                                    children: [
                                      (command.Pipeline
                                        children: [
                                          (C {($ VSub_DollarName '$ECHO')} 
                                            {(DQ ($ VSub_DollarName '$func_normal_abspath_tpath'))}
                                          )
                                          (C {($ VSub_DollarName '$SED')} {(-e)} 
                                            {(DQ ($ VSub_DollarName '$_G_pathcdr'))}
                                          )
                                        ]
                                        negated: F
                                      )
                                    ]
                                  )
                              )
                            }
                        )
                      ]
                    )
                    (command.Case
                      to_match: {($ VSub_DollarName '$func_normal_abspath_tcomponent')}
                      arms: [
                        (case_arm pat_list:[{(DQ )}])
                        (case_arm
                          pat_list: [{(..)}]
                          action: [
                            (C {(func_dirname)} {(DQ ($ VSub_DollarName '$func_normal_abspath_result'))})
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:func_normal_abspath_result)
                                  op: Equal
                                  rhs: {($ VSub_DollarName '$func_dirname_result')}
                                )
                              ]
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(Lit_Star '*')}]
                          action: [
                            (C {(func_append)} {(func_normal_abspath_result)} 
                              {(DQ (/) ($ VSub_DollarName '$func_normal_abspath_tcomponent'))}
                            )
                          ]
                        )
                      ]
                    )
                  ]
                )
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:func_normal_abspath_result)
                  op: Equal
                  rhs: 
                    {($ VSub_DollarName '$func_normal_abspath_altnamespace') 
                      ($ VSub_DollarName '$func_normal_abspath_result')
                    }
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: func_notquiet
      body: 
        (command.BraceGroup
          children: [
            (C {($ VSub_DollarName '$debug_cmd')})
            (command.AndOr
              ops: [Op_DPipe]
              children: [
                (C {($ VSub_DollarName '$opt_quiet')})
                (C {(func_echo)} 
                  {
                    (braced_var_sub
                      token: <VSub_Number 1>
                      suffix_op: (suffix_op.Unary op_id:VTest_Plus arg_word:{(DQ ($ VSub_At '$@'))})
                    )
                  }
                )
              ]
            )
            (C {(Lit_Other ':')})
          ]
        )
    )
    (command.ShFunction
      name: func_relative_path
      body: 
        (command.BraceGroup
          children: [
            (C {($ VSub_DollarName '$debug_cmd')})
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:func_relative_path_result) op:Equal rhs:(word.Empty))]
            )
            (C {(func_normal_abspath)} {(DQ ($ VSub_Number '$1'))})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:func_relative_path_tlibdir)
                  op: Equal
                  rhs: {($ VSub_DollarName '$func_normal_abspath_result')}
                )
              ]
            )
            (C {(func_normal_abspath)} {(DQ ($ VSub_Number '$2'))})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:func_relative_path_tbindir)
                  op: Equal
                  rhs: {($ VSub_DollarName '$func_normal_abspath_result')}
                )
              ]
            )
            (command.WhileUntil
              keyword: <KW_While while>
              cond: [(command.Sentence child:(C {(Lit_Other ':')}) terminator:<Op_Semi ';'>)]
              body: 
                (command.DoGroup
                  children: [
                    (command.Case
                      to_match: {($ VSub_DollarName '$func_relative_path_tbindir')}
                      arms: [
                        (case_arm
                          pat_list: [{($ VSub_DollarName '$func_relative_path_tlibdir')}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:func_relative_path_tcancelled)
                                  op: Equal
                                  rhs: (word.Empty)
                                )
                              ]
                            )
                            (command.ControlFlow
                              token: <ControlFlow_Break break>
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [
                            {($ VSub_DollarName '$func_relative_path_tlibdir') (Lit_Star '*')}
                          ]
                          action: [
                            (C {(func_stripname)} 
                              {(DQ ($ VSub_DollarName '$func_relative_path_tlibdir'))} {(SQ )} {(DQ ($ VSub_DollarName '$func_relative_path_tbindir'))}
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:func_relative_path_tcancelled)
                                  op: Equal
                                  rhs: {($ VSub_DollarName '$func_stripname_result')}
                                )
                              ]
                            )
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (C {(test)} {(-z)} 
                                          {(DQ ($ VSub_DollarName '$func_relative_path_result'))}
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:func_relative_path_result)
                                          op: Equal
                                          rhs: {(.)}
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.ControlFlow
                              token: <ControlFlow_Break break>
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(Lit_Star '*')}]
                          action: [
                            (C {(func_dirname)} {($ VSub_DollarName '$func_relative_path_tlibdir')})
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:func_relative_path_tlibdir)
                                  op: Equal
                                  rhs: {($ VSub_DollarName '$func_dirname_result')}
                                )
                              ]
                            )
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (C {(test)} {(-z)} 
                                          {(DQ ($ VSub_DollarName '$func_relative_path_tlibdir'))}
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:func_relative_path_result)
                                          op: Equal
                                          rhs: 
                                            {(../) ($ VSub_DollarName '$func_relative_path_result')}
                                        )
                                      ]
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:func_relative_path_tcancelled)
                                          op: Equal
                                          rhs: {($ VSub_DollarName '$func_relative_path_tbindir')}
                                        )
                                      ]
                                    )
                                    (command.ControlFlow
                                      token: <ControlFlow_Break break>
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:func_relative_path_result)
                                  op: Equal
                                  rhs: {(../) ($ VSub_DollarName '$func_relative_path_result')}
                                )
                              ]
                            )
                          ]
                        )
                      ]
                    )
                  ]
                )
            )
            (C {(func_stripname)} {(SQ )} {(SQ </>)} 
              {(DQ ($ VSub_DollarName '$func_relative_path_result'))}
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:func_relative_path_result)
                  op: Equal
                  rhs: {($ VSub_DollarName '$func_stripname_result')}
                )
              ]
            )
            (C {(func_stripname)} {(SQ </>)} {(SQ </>)} 
              {(DQ ($ VSub_DollarName '$func_relative_path_tcancelled'))}
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$func_stripname_result'))})
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (C {(func_append)} {(func_relative_path_result)} 
                      {(DQ (/) ($ VSub_DollarName '$func_stripname_result'))}
                    )
                  ]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$func_relative_path_result'))})
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (C {(func_stripname)} {(SQ <./>)} {(SQ )} 
                      {(DQ ($ VSub_DollarName '$func_relative_path_result'))}
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:func_relative_path_result)
                          op: Equal
                          rhs: {($ VSub_DollarName '$func_stripname_result')}
                        )
                      ]
                    )
                  ]
                )
              ]
            )
            (command.AndOr
              ops: [Op_DPipe]
              children: [
                (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$func_relative_path_result'))})
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:func_relative_path_result)
                      op: Equal
                      rhs: {(.)}
                    )
                  ]
                )
              ]
            )
            (C {(Lit_Other ':')})
          ]
        )
    )
    (command.ShFunction
      name: func_quote_for_eval
      body: 
        (command.BraceGroup
          children: [
            (C {($ VSub_DollarName '$debug_cmd')})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:func_quote_for_eval_unquoted_result)
                  op: Equal
                  rhs: (word.Empty)
                )
              ]
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:func_quote_for_eval_result) op:Equal rhs:(word.Empty))]
            )
            (command.WhileUntil
              keyword: <KW_While while>
              cond: [
                (command.Sentence
                  child: (C {(test)} {(0)} {(-lt)} {($ VSub_Pound '$#')})
                  terminator: <Op_Semi ';'>
                )
              ]
              body: 
                (command.DoGroup
                  children: [
                    (command.Case
                      to_match: {($ VSub_Number '$1')}
                      arms: [
                        (case_arm
                          pat_list: [
                            {(Lit_Star '*') (Lit_LBracket '[') 
                              (word_part.EscapedLiteral
                                token: <Lit_EscapedChar '\\\\'>
                              ) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\`'>) 
                              (word_part.EscapedLiteral
                                token: <Lit_EscapedChar '\\"'>
                              ) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) (Lit_RBracket ']') (Lit_Star '*')
                            }
                          ]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:_G_unquoted_arg)
                                  op: Equal
                                  rhs: 
                                    {
                                      (command_sub
                                        left_token: <Left_Backtick '`'>
                                        command_list: 
                                          (command.CommandList
                                            children: [
                                              (command.Pipeline
                                                children: [
                                                  (C {(printf)} {(SQ <'%s\\n'>)} 
                                                    {(DQ ($ VSub_Number '$1'))}
                                                  )
                                                  (C {($ VSub_DollarName '$SED')} 
                                                    {(DQ ($ VSub_DollarName '$sed_quote_subst'))}
                                                  )
                                                ]
                                                negated: F
                                              )
                                            ]
                                          )
                                      )
                                    }
                                )
                              ]
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(Lit_Star '*')}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:_G_unquoted_arg)
                                  op: Equal
                                  rhs: {($ VSub_Number '$1')}
                                )
                              ]
                            )
                          ]
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: 
                                (C {(test)} {(-n)} 
                                  {(DQ ($ VSub_DollarName '$func_quote_for_eval_unquoted_result'))}
                                )
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [
                            (C {(func_append)} {(func_quote_for_eval_unquoted_result)} 
                              {(DQ (' ') ($ VSub_DollarName '$_G_unquoted_arg'))}
                            )
                          ]
                        )
                      ]
                      else_action: [
                        (C {(func_append)} {(func_quote_for_eval_unquoted_result)} 
                          {(DQ ($ VSub_DollarName '$_G_unquoted_arg'))}
                        )
                      ]
                    )
                    (command.Case
                      to_match: {($ VSub_DollarName '$_G_unquoted_arg')}
                      arms: [
                        (case_arm
                          pat_list: [
                            {(Lit_Star '*') (Lit_LBracket '[') 
                              (word_part.EscapedLiteral
                                token: <Lit_EscapedChar '\\['>
                              ) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\~'>) 
                              (word_part.EscapedLiteral
                                token: <Lit_EscapedChar '\\#'>
                              ) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\^'>) 
                              (word_part.EscapedLiteral
                                token: <Lit_EscapedChar '\\&'>
                              ) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\*'>) 
                              (word_part.EscapedLiteral
                                token: <Lit_EscapedChar '\\('>
                              ) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\)'>) 
                              (word_part.EscapedLiteral
                                token: <Lit_EscapedChar '\\{'>
                              ) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\}'>) 
                              (word_part.EscapedLiteral
                                token: <Lit_EscapedChar '\\|'>
                              ) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\;'>) 
                              (word_part.EscapedLiteral
                                token: <Lit_EscapedChar '\\<'>
                              ) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\>'>) 
                              (word_part.EscapedLiteral
                                token: <Lit_EscapedChar '\\?'>
                              ) (word_part.EscapedLiteral token:<Lit_EscapedChar "\\'">) 
                              (word_part.EscapedLiteral
                                token: <Lit_EscapedChar '\\ '>
                              ) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\\t'>) (Lit_RBracket ']') (Lit_Star '*')
                            }
                            {(Lit_Star '*') (Lit_RBracket ']') (Lit_Star '*')}
                            {(DQ )}
                          ]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:_G_quoted_arg)
                                  op: Equal
                                  rhs: 
                                    {(word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) 
                                      ($ VSub_DollarName '$_G_unquoted_arg') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>)
                                    }
                                )
                              ]
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(Lit_Star '*')}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:_G_quoted_arg)
                                  op: Equal
                                  rhs: {($ VSub_DollarName '$_G_unquoted_arg')}
                                )
                              ]
                            )
                          ]
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: 
                                (C {(test)} {(-n)} 
                                  {(DQ ($ VSub_DollarName '$func_quote_for_eval_result'))}
                                )
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [
                            (C {(func_append)} {(func_quote_for_eval_result)} 
                              {(DQ (' ') ($ VSub_DollarName '$_G_quoted_arg'))}
                            )
                          ]
                        )
                      ]
                      else_action: [
                        (C {(func_append)} {(func_quote_for_eval_result)} 
                          {(DQ ($ VSub_DollarName '$_G_quoted_arg'))}
                        )
                      ]
                    )
                    (C {(shift)})
                  ]
                )
            )
          ]
        )
    )
    (command.ShFunction
      name: func_quote_for_expand
      body: 
        (command.BraceGroup
          children: [
            (C {($ VSub_DollarName '$debug_cmd')})
            (command.Case
              to_match: {($ VSub_Number '$1')}
              arms: [
                (case_arm
                  pat_list: [
                    {(Lit_Star '*') (Lit_LBracket '[') 
                      (word_part.EscapedLiteral token:<Lit_EscapedChar '\\\\'>) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\`'>) 
                      (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) (Lit_RBracket ']') (Lit_Star '*')
                    }
                  ]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:_G_arg)
                          op: Equal
                          rhs: 
                            {
                              (command_sub
                                left_token: <Left_Backtick '`'>
                                command_list: 
                                  (command.CommandList
                                    children: [
                                      (command.Pipeline
                                        children: [
                                          (C {($ VSub_DollarName '$ECHO')} {(DQ ($ VSub_Number '$1'))})
                                          (C {($ VSub_DollarName '$SED')} {(-e)} 
                                            {(DQ ($ VSub_DollarName '$sed_double_quote_subst'))} {(-e)} {(DQ ($ VSub_DollarName '$sed_double_backslash'))}
                                          )
                                        ]
                                        negated: F
                                      )
                                    ]
                                  )
                              )
                            }
                        )
                      ]
                    )
                  ]
                )
                (case_arm
                  pat_list: [{(Lit_Star '*')}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:_G_arg)
                          op: Equal
                          rhs: {($ VSub_Number '$1')}
                        )
                      ]
                    )
                  ]
                )
              ]
            )
            (command.Case
              to_match: {($ VSub_DollarName '$_G_arg')}
              arms: [
                (case_arm
                  pat_list: [
                    {(Lit_Star '*') (Lit_LBracket '[') 
                      (word_part.EscapedLiteral token:<Lit_EscapedChar '\\['>) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\~'>) 
                      (word_part.EscapedLiteral token:<Lit_EscapedChar '\\#'>) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\^'>) 
                      (word_part.EscapedLiteral token:<Lit_EscapedChar '\\&'>) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\*'>) 
                      (word_part.EscapedLiteral token:<Lit_EscapedChar '\\('>) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\)'>) 
                      (word_part.EscapedLiteral token:<Lit_EscapedChar '\\{'>) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\}'>) 
                      (word_part.EscapedLiteral token:<Lit_EscapedChar '\\|'>) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\;'>) 
                      (word_part.EscapedLiteral token:<Lit_EscapedChar '\\<'>) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\>'>) 
                      (word_part.EscapedLiteral token:<Lit_EscapedChar '\\?'>) (word_part.EscapedLiteral token:<Lit_EscapedChar "\\'">) 
                      (word_part.EscapedLiteral token:<Lit_EscapedChar '\\ '>) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\\t'>) (Lit_RBracket ']') (Lit_Star '*')
                    }
                    {(Lit_Star '*') (Lit_RBracket ']') (Lit_Star '*')}
                    {(DQ )}
                  ]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:_G_arg)
                          op: Equal
                          rhs: 
                            {(word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) 
                              ($ VSub_DollarName '$_G_arg') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>)
                            }
                        )
                      ]
                    )
                  ]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:func_quote_for_expand_result)
                  op: Equal
                  rhs: {($ VSub_DollarName '$_G_arg')}
                )
              ]
            )
          ]
        )
    )
    (command.If
      arms: [
        (if_arm
          cond: [
            (command.Sentence
              child: 
                (C {(test)} {(yes)} {(Lit_Equals '=')} {(DQ ($ VSub_DollarName '$_G_HAVE_XSI_OPS'))})
              terminator: <Op_Semi ';'>
            )
          ]
          action: [
            (C {(eval)} 
              {
                (SQ <'func_stripname ()\n'> <'  {\n'> <'    $debug_cmd\n'> <'\n'> 
                  <'    # pdksh 5.2.14 does not do ${X%$Y} correctly if both X and Y are\n'> <'    # positional parameters, so assign one to ordinary variable first.\n'> 
                  <'    func_stripname_result=$3\n'> <'    func_stripname_result=${func_stripname_result#"$1"}\n'> 
                  <'    func_stripname_result=${func_stripname_result%"$2"}\n'> <'  }'>
                )
              }
            )
          ]
        )
      ]
      else_action: [
        (command.ShFunction
          name: func_stripname
          body: 
            (command.BraceGroup
              children: [
                (C {($ VSub_DollarName '$debug_cmd')})
                (command.Case
                  to_match: {($ VSub_Number '$2')}
                  arms: [
                    (case_arm
                      pat_list: [{(.) (Lit_Star '*')}]
                      action: [
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:func_stripname_result)
                              op: Equal
                              rhs: 
                                {
                                  (command_sub
                                    left_token: <Left_Backtick '`'>
                                    command_list: 
                                      (command.CommandList
                                        children: [
                                          (command.Pipeline
                                            children: [
                                              (C {($ VSub_DollarName '$ECHO')} 
                                                {(DQ ($ VSub_Number '$3'))}
                                              )
                                              (C {($ VSub_DollarName '$SED')} {(-e)} 
                                                {(DQ ('s%^') ($ VSub_Number '$1') ('%%'))} {(-e)} 
                                                {
                                                  (DQ ('s%') 
                                                    (word_part.EscapedLiteral
                                                      token: <Lit_EscapedChar '\\\\'>
                                                    ) ($ VSub_Number '$2') (Lit_Other '$') ('%%')
                                                  )
                                                }
                                              )
                                            ]
                                            negated: F
                                          )
                                        ]
                                      )
                                  )
                                }
                            )
                          ]
                        )
                      ]
                    )
                    (case_arm
                      pat_list: [{(Lit_Star '*')}]
                      action: [
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:func_stripname_result)
                              op: Equal
                              rhs: 
                                {
                                  (command_sub
                                    left_token: <Left_Backtick '`'>
                                    command_list: 
                                      (command.CommandList
                                        children: [
                                          (command.Pipeline
                                            children: [
                                              (C {($ VSub_DollarName '$ECHO')} 
                                                {(DQ ($ VSub_Number '$3'))}
                                              )
                                              (C {($ VSub_DollarName '$SED')} {(-e)} 
                                                {(DQ ('s%^') ($ VSub_Number '$1') ('%%'))} {(-e)} {(DQ ('s%') ($ VSub_Number '$2') (Lit_Other '$') ('%%'))}
                                              )
                                            ]
                                            negated: F
                                          )
                                        ]
                                      )
                                  )
                                }
                            )
                          ]
                        )
                      ]
                    )
                  ]
                )
              ]
            )
        )
      ]
    )
    (command.ShFunction
      name: func_show_eval
      body: 
        (command.BraceGroup
          children: [
            (C {($ VSub_DollarName '$debug_cmd')})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:_G_cmd)
                  op: Equal
                  rhs: {($ VSub_Number '$1')}
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:_G_fail_exp)
                  op: Equal
                  rhs: 
                    {
                      (braced_var_sub
                        token: <VSub_Number 2>
                        suffix_op: (suffix_op.Unary op_id:VTest_Hyphen arg_word:{(SQ <':'>)})
                      )
                    }
                )
              ]
            )
            (C {(func_quote_for_expand)} {(DQ ($ VSub_DollarName '$_G_cmd'))})
            (C {(eval)} {(DQ ('func_notquiet ') ($ VSub_DollarName '$func_quote_for_expand_result'))})
            (command.AndOr
              ops: [Op_DPipe]
              children: [
                (C {($ VSub_DollarName '$opt_dry_run')})
                (command.BraceGroup
                  children: [
                    (C {(eval)} {(DQ ($ VSub_DollarName '$_G_cmd'))})
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:_G_status)
                          op: Equal
                          rhs: {($ VSub_QMark '$?')}
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: (C {(test)} {(0)} {(-ne)} {(DQ ($ VSub_DollarName '$_G_status'))})
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [
                            (C {(eval)} 
                              {
                                (DQ ('(exit ') ($ VSub_DollarName '$_G_status') ('); ') 
                                  ($ VSub_DollarName '$_G_fail_exp')
                                )
                              }
                            )
                          ]
                        )
                      ]
                    )
                  ]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: func_show_eval_locale
      body: 
        (command.BraceGroup
          children: [
            (C {($ VSub_DollarName '$debug_cmd')})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:_G_cmd)
                  op: Equal
                  rhs: {($ VSub_Number '$1')}
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:_G_fail_exp)
                  op: Equal
                  rhs: 
                    {
                      (braced_var_sub
                        token: <VSub_Number 2>
                        suffix_op: (suffix_op.Unary op_id:VTest_Hyphen arg_word:{(SQ <':'>)})
                      )
                    }
                )
              ]
            )
            (command.AndOr
              ops: [Op_DPipe]
              children: [
                (C {($ VSub_DollarName '$opt_quiet')})
                (command.BraceGroup
                  children: [
                    (C {(func_quote_for_expand)} {(DQ ($ VSub_DollarName '$_G_cmd'))})
                    (C {(eval)} 
                      {(DQ ('func_echo ') ($ VSub_DollarName '$func_quote_for_expand_result'))}
                    )
                  ]
                )
              ]
            )
            (command.AndOr
              ops: [Op_DPipe]
              children: [
                (C {($ VSub_DollarName '$opt_dry_run')})
                (command.BraceGroup
                  children: [
                    (C {(eval)} 
                      {
                        (DQ ($ VSub_DollarName '$_G_user_locale') ('\n') ('\t    ') 
                          ($ VSub_DollarName '$_G_cmd')
                        )
                      }
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:_G_status)
                          op: Equal
                          rhs: {($ VSub_QMark '$?')}
                        )
                      ]
                    )
                    (C {(eval)} {(DQ ($ VSub_DollarName '$_G_safe_locale'))})
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: (C {(test)} {(0)} {(-ne)} {(DQ ($ VSub_DollarName '$_G_status'))})
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [
                            (C {(eval)} 
                              {
                                (DQ ('(exit ') ($ VSub_DollarName '$_G_status') ('); ') 
                                  ($ VSub_DollarName '$_G_fail_exp')
                                )
                              }
                            )
                          ]
                        )
                      ]
                    )
                  ]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: func_tr_sh
      body: 
        (command.BraceGroup
          children: [
            (C {($ VSub_DollarName '$debug_cmd')})
            (command.Case
              to_match: {($ VSub_Number '$1')}
              arms: [
                (case_arm
                  pat_list: [
                    {(Lit_LBracket '[') (0-9) (Lit_RBracket ']') (Lit_Star '*')}
                    {(Lit_Star '*') (Lit_LBracket '[') (KW_Bang '!') (a-zA-Z0-9_) (Lit_RBracket ']') 
                      (Lit_Star '*')
                    }
                  ]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:func_tr_sh_result)
                          op: Equal
                          rhs: 
                            {
                              (command_sub
                                left_token: <Left_Backtick '`'>
                                command_list: 
                                  (command.CommandList
                                    children: [
                                      (command.Pipeline
                                        children: [
                                          (C {($ VSub_DollarName '$ECHO')} {(DQ ($ VSub_Number '$1'))})
                                          (C {($ VSub_DollarName '$SED')} {(-e)} 
                                            {(SQ <'s/^\\([0-9]\\)/_\\1/'>)} {(-e)} {(SQ <'s/[^a-zA-Z0-9_]/_/g'>)}
                                          )
                                        ]
                                        negated: F
                                      )
                                    ]
                                  )
                              )
                            }
                        )
                      ]
                    )
                  ]
                )
                (case_arm
                  pat_list: [{(Lit_Star '*')}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:func_tr_sh_result)
                          op: Equal
                          rhs: {($ VSub_Number '$1')}
                        )
                      ]
                    )
                  ]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: func_verbose
      body: 
        (command.BraceGroup
          children: [
            (C {($ VSub_DollarName '$debug_cmd')})
            (command.AndOr
              ops: [Op_DAmp]
              children: [
                (C {($ VSub_DollarName '$opt_verbose')})
                (C {(func_echo)} {(DQ ($ VSub_Star '$*'))})
              ]
            )
            (C {(Lit_Other ':')})
          ]
        )
    )
    (command.ShFunction
      name: func_warn_and_continue
      body: 
        (command.BraceGroup
          children: [
            (C {($ VSub_DollarName '$debug_cmd')})
            (C {($ VSub_DollarName '$require_term_colors')})
            (command.Simple
              words: [
                {(func_echo_infix_1)}
                {(DQ (${ VSub_Name tc_red) (warning) ($ VSub_DollarName '$tc_reset'))}
                {(DQ ($ VSub_Star '$*'))}
              ]
              redirects: [(redir.Redir op:<Redir_GreatAnd '>&'> fd:16777215 arg_word:{(2)})]
            )
          ]
        )
    )
    (command.ShFunction
      name: func_warning
      body: 
        (command.BraceGroup
          children: [
            (C {($ VSub_DollarName '$debug_cmd')})
            (command.Case
              to_match: {(DQ (' ') ($ VSub_DollarName '$warning_categories') (' '))}
              arms: [
                (case_arm
                  pat_list: [{(Lit_Star '*') (DQ (' ') ($ VSub_Number '$1') (' ')) (Lit_Star '*')}]
                )
                (case_arm
                  pat_list: [{(Lit_Star '*')}]
                  action: [
                    (C {(func_internal_error)} 
                      {(DQ ("invalid warning category '") ($ VSub_Number '$1') ("'"))}
                    )
                  ]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:_G_category)
                  op: Equal
                  rhs: {($ VSub_Number '$1')}
                )
              ]
            )
            (C {(shift)})
            (command.Case
              to_match: {(DQ (' ') ($ VSub_DollarName '$opt_warning_types') (' '))}
              arms: [
                (case_arm
                  pat_list: [
                    {(Lit_Star '*') (DQ (' ') ($ VSub_DollarName '$_G_category') (' ')) (Lit_Star '*')}
                  ]
                  action: [
                    (C {($ VSub_DollarName '$warning_func')} 
                      {
                        (braced_var_sub
                          token: <VSub_Number 1>
                          suffix_op: (suffix_op.Unary op_id:VTest_Plus arg_word:{(DQ ($ VSub_At '$@'))})
                        )
                      }
                    )
                  ]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: func_sort_ver
      body: 
        (command.BraceGroup
          children: [
            (C {($ VSub_DollarName '$debug_cmd')})
            (command.Pipeline
              children: [
                (C {(printf)} {(SQ <'%s\\n%s\\n'>)} {(DQ ($ VSub_Number '$1'))} 
                  {(DQ ($ VSub_Number '$2'))}
                )
                (C {(sort)} {(-t.)} {(-k)} {(1) (Lit_Comma ',') (1n)} {(-k)} {(2) (Lit_Comma ',') (2n)} 
                  {(-k)} {(3) (Lit_Comma ',') (3n)} {(-k)} {(4) (Lit_Comma ',') (4n)} {(-k)} {(5) (Lit_Comma ',') (5n)} {(-k)} 
                  {(6) (Lit_Comma ',') (6n)} {(-k)} {(7) (Lit_Comma ',') (7n)} {(-k)} {(8) (Lit_Comma ',') (8n)} {(-k)} {(9) (Lit_Comma ',') (9n)}
                )
              ]
              negated: F
            )
          ]
        )
    )
    (command.ShFunction
      name: func_lt_ver
      body: 
        (command.BraceGroup
          children: [
            (C {($ VSub_DollarName '$debug_cmd')})
            (C {(test)} {(DQ (x) ($ VSub_Number '$1'))} {(Lit_Equals '=')} 
              {(x) 
                (command_sub
                  left_token: <Left_Backtick '`'>
                  command_list: 
                    (command.CommandList
                      children: [
                        (command.Pipeline
                          children: [
                            (C {(func_sort_ver)} {(DQ ($ VSub_Number '$1'))} {(DQ ($ VSub_Number '$2'))})
                            (C {($ VSub_DollarName '$SED')} {(1q)})
                          ]
                          negated: F
                        )
                      ]
                    )
                )
              }
            )
          ]
        )
    )
    (command.Sentence
      child: 
        (command.ShAssignment
          pairs: [
            (assign_pair
              lhs: (sh_lhs_expr.Name name:scriptversion)
              op: Equal
              rhs: {(2014-01-07.03)}
            )
          ]
        )
      terminator: <Op_Semi ';'>
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:usage)
          op: Equal
          rhs: {(SQ <'$progpath [OPTION]...'>)}
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:usage_message)
          op: Equal
          rhs: 
            {
              (DQ ('       --debug        enable verbose shell tracing\n') 
                ('   -W, --warnings=CATEGORY\n') ('                      report the warnings falling in CATEGORY [all]\n') 
                ('   -v, --verbose      verbosely report processing\n') ('       --version      print version information and exit\n') 
                ('   -h, --help         print short or long help message and exit\n')
              )
            }
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:long_help_message)
          op: Equal
          rhs: 
            {
              (DQ ('\n') ('Warning categories include:\n') 
                ("       'all'          show all warnings\n") ("       'none'         turn off all the warnings\n") 
                ("       'error'        warnings are treated as fatal errors")
              )
            }
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:fatal_help)
          op: Equal
          rhs: 
            {
              (DQ ("Try '") (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) 
                ("progname --help' for more information.")
              )
            }
        )
      ]
    )
    (command.ShFunction
      name: func_hookable
      body: 
        (command.BraceGroup
          children: [
            (C {($ VSub_DollarName '$debug_cmd')})
            (C {(func_append)} {(hookable_fns)} {(DQ (' ') ($ VSub_Number '$1'))})
          ]
        )
    )
    (command.ShFunction
      name: func_add_hook
      body: 
        (command.BraceGroup
          children: [
            (C {($ VSub_DollarName '$debug_cmd')})
            (command.Case
              to_match: {(DQ (' ') ($ VSub_DollarName '$hookable_fns') (' '))}
              arms: [
                (case_arm
                  pat_list: [{(Lit_Star '*') (DQ (' ') ($ VSub_Number '$1') (' ')) (Lit_Star '*')}]
                )
                (case_arm
                  pat_list: [{(Lit_Star '*')}]
                  action: [
                    (C {(func_fatal_error)} 
                      {(DQ ("'") ($ VSub_Number '$1') ("' does not accept hook functions."))}
                    )
                  ]
                )
              ]
            )
            (C {(eval)} {(func_append)} {(${ VSub_Number 1) (_hooks)} {(SQ <'" $2"'>)})
          ]
        )
    )
    (command.ShFunction
      name: func_remove_hook
      body: 
        (command.BraceGroup
          children: [
            (C {($ VSub_DollarName '$debug_cmd')})
            (C {(eval)} 
              {(${ VSub_Number 1) (Lit_VarLike '_hooks=') (SQ <'`$ECHO "\\$'>) ($ VSub_Number '$1') 
                (SQ <'_hooks" |$SED "s| '>) ($ VSub_Number '$2') (SQ <'||"`'>)
              }
            )
          ]
        )
    )
    (command.ShFunction
      name: func_run_hooks
      body: 
        (command.BraceGroup
          children: [
            (C {($ VSub_DollarName '$debug_cmd')})
            (command.Case
              to_match: {(DQ (' ') ($ VSub_DollarName '$hookable_fns') (' '))}
              arms: [
                (case_arm
                  pat_list: [{(Lit_Star '*') (DQ (' ') ($ VSub_Number '$1') (' ')) (Lit_Star '*')}]
                )
                (case_arm
                  pat_list: [{(Lit_Star '*')}]
                  action: [
                    (C {(func_fatal_error)} 
                      {(DQ ("'") ($ VSub_Number '$1') ("' does not support hook funcions.n"))}
                    )
                  ]
                )
              ]
            )
            (command.Sentence
              child: 
                (C {(eval)} 
                  {(Lit_VarLike '_G_hook_fns=') 
                    (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) ($ VSub_Number '$1') (_hooks)
                  }
                )
              terminator: <Op_Semi ';'>
            )
            (C {(shift)})
            (command.ForEach
              iter_name: _G_hook
              iter_words: [{($ VSub_DollarName '$_G_hook_fns')}]
              do_arg_iter: F
              body: 
                (command.DoGroup
                  children: [
                    (C {(eval)} {($ VSub_DollarName '$_G_hook')} {(SQ <'"$@"'>)})
                    (C {(eval)} 
                      {(Lit_VarLike '_G_hook_result=') 
                        (word_part.EscapedLiteral
                          token: <Lit_EscapedChar '\\$'>
                        ) (${ VSub_Name _G_hook) (_result)
                      }
                    )
                    (command.Sentence
                      child: 
                        (C {(eval)} {(KW_Set set)} {(dummy)} {(DQ ($ VSub_DollarName '$_G_hook_result'))})
                      terminator: <Op_Semi ';'>
                    )
                    (C {(shift)})
                  ]
                )
            )
            (C {(func_quote_for_eval)} 
              {
                (braced_var_sub
                  token: <VSub_Number 1>
                  suffix_op: (suffix_op.Unary op_id:VTest_Plus arg_word:{(DQ ($ VSub_At '$@'))})
                )
              }
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:func_run_hooks_result)
                  op: Equal
                  rhs: {($ VSub_DollarName '$func_quote_for_eval_result')}
                )
              ]
            )
          ]
        )
    )
    (C {(func_hookable)} {(func_options)})
    (command.ShFunction
      name: func_options
      body: 
        (command.BraceGroup
          children: [
            (C {($ VSub_DollarName '$debug_cmd')})
            (C {(func_options_prep)} 
              {
                (braced_var_sub
                  token: <VSub_Number 1>
                  suffix_op: (suffix_op.Unary op_id:VTest_Plus arg_word:{(DQ ($ VSub_At '$@'))})
                )
              }
            )
            (C {(eval)} {(func_parse_options)} 
              {
                (braced_var_sub
                  token: <VSub_Name func_options_prep_result>
                  suffix_op: 
                    (suffix_op.Unary
                      op_id: VTest_Plus
                      arg_word: {(DQ ($ VSub_DollarName '$func_options_prep_result'))}
                    )
                )
              }
            )
            (C {(eval)} {(func_validate_options)} 
              {
                (braced_var_sub
                  token: <VSub_Name func_parse_options_result>
                  suffix_op: 
                    (suffix_op.Unary
                      op_id: VTest_Plus
                      arg_word: {(DQ ($ VSub_DollarName '$func_parse_options_result'))}
                    )
                )
              }
            )
            (C {(eval)} {(func_run_hooks)} {(func_options)} 
              {
                (braced_var_sub
                  token: <VSub_Name func_validate_options_result>
                  suffix_op: 
                    (suffix_op.Unary
                      op_id: VTest_Plus
                      arg_word: {(DQ ($ VSub_DollarName '$func_validate_options_result'))}
                    )
                )
              }
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:func_options_result)
                  op: Equal
                  rhs: {($ VSub_DollarName '$func_run_hooks_result')}
                )
              ]
            )
          ]
        )
    )
    (C {(func_hookable)} {(func_options_prep)})
    (command.ShFunction
      name: func_options_prep
      body: 
        (command.BraceGroup
          children: [
            (C {($ VSub_DollarName '$debug_cmd')})
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:opt_verbose) op:Equal rhs:{(false)})]
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:opt_warning_types) op:Equal rhs:(word.Empty))]
            )
            (C {(func_run_hooks)} {(func_options_prep)} 
              {
                (braced_var_sub
                  token: <VSub_Number 1>
                  suffix_op: (suffix_op.Unary op_id:VTest_Plus arg_word:{(DQ ($ VSub_At '$@'))})
                )
              }
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:func_options_prep_result)
                  op: Equal
                  rhs: {($ VSub_DollarName '$func_run_hooks_result')}
                )
              ]
            )
          ]
        )
    )
    (C {(func_hookable)} {(func_parse_options)})
    (command.ShFunction
      name: func_parse_options
      body: 
        (command.BraceGroup
          children: [
            (C {($ VSub_DollarName '$debug_cmd')})
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:func_parse_options_result) op:Equal rhs:(word.Empty))]
            )
            (command.WhileUntil
              keyword: <KW_While while>
              cond: [
                (command.Sentence
                  child: (C {(test)} {($ VSub_Pound '$#')} {(-gt)} {(0)})
                  terminator: <Op_Semi ';'>
                )
              ]
              body: 
                (command.DoGroup
                  children: [
                    (C {(func_run_hooks)} {(func_parse_options)} 
                      {
                        (braced_var_sub
                          token: <VSub_Number 1>
                          suffix_op: (suffix_op.Unary op_id:VTest_Plus arg_word:{(DQ ($ VSub_At '$@'))})
                        )
                      }
                    )
                    (command.Sentence
                      child: 
                        (C {(eval)} {(KW_Set set)} {(dummy)} 
                          {(DQ ($ VSub_DollarName '$func_run_hooks_result'))}
                        )
                      terminator: <Op_Semi ';'>
                    )
                    (C {(shift)})
                    (command.AndOr
                      ops: [Op_DPipe]
                      children: [
                        (C {(test)} {($ VSub_Pound '$#')} {(-gt)} {(0)})
                        (command.ControlFlow token:<ControlFlow_Break break>)
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:_G_opt)
                          op: Equal
                          rhs: {($ VSub_Number '$1')}
                        )
                      ]
                    )
                    (C {(shift)})
                    (command.Case
                      to_match: {($ VSub_DollarName '$_G_opt')}
                      arms: [
                        (case_arm
                          pat_list: [{(--debug)} {(-x)}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:debug_cmd)
                                  op: Equal
                                  rhs: {(SQ <'set -x'>)}
                                )
                              ]
                            )
                            (C {(func_echo)} {(DQ ('enabling shell trace mode'))})
                            (C {($ VSub_DollarName '$debug_cmd')})
                          ]
                        )
                        (case_arm
                          pat_list: [{(--no-warnings)} {(--no-warning)} {(--no-warn)}]
                          action: [
                            (C {(KW_Set set)} {(dummy)} {(--warnings)} {(none)} 
                              {
                                (braced_var_sub
                                  token: <VSub_Number 1>
                                  suffix_op: 
                                    (suffix_op.Unary
                                      op_id: VTest_Plus
                                      arg_word: {(DQ ($ VSub_At '$@'))}
                                    )
                                )
                              }
                            )
                            (C {(shift)})
                          ]
                        )
                        (case_arm
                          pat_list: [{(--warnings)} {(--warning)} {(-W)}]
                          action: [
                            (command.AndOr
                              ops: [Op_DAmp Op_DAmp]
                              children: [
                                (C {(test)} {($ VSub_Pound '$#')} {(Lit_Equals '=')} {(0)})
                                (C {(func_missing_arg)} {($ VSub_DollarName '$_G_opt')})
                                (command.ControlFlow
                                  token: <ControlFlow_Break break>
                                )
                              ]
                            )
                            (command.Case
                              to_match: 
                                {
                                  (DQ (' ') ($ VSub_DollarName '$warning_categories') (' ') 
                                    ($ VSub_Number '$1')
                                  )
                                }
                              arms: [
                                (case_arm
                                  pat_list: [
                                    {(Lit_Star '*') (DQ (' ') ($ VSub_Number '$1') (' ')) 
                                      (Lit_Star '*')
                                    }
                                  ]
                                  action: [
                                    (C {(func_append_uniq)} {(opt_warning_types)} 
                                      {(DQ (' ') ($ VSub_Number '$1'))}
                                    )
                                  ]
                                )
                                (case_arm
                                  pat_list: [{(Lit_Star '*') (all)}]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:opt_warning_types)
                                          op: Equal
                                          rhs: {($ VSub_DollarName '$warning_categories')}
                                        )
                                      ]
                                    )
                                  ]
                                )
                                (case_arm
                                  pat_list: [{(Lit_Star '*') (none)}]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:opt_warning_types)
                                          op: Equal
                                          rhs: {(none)}
                                        )
                                      ]
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:warning_func)
                                          op: Equal
                                          rhs: {(Lit_Other ':')}
                                        )
                                      ]
                                    )
                                  ]
                                )
                                (case_arm
                                  pat_list: [{(Lit_Star '*') (error)}]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:opt_warning_types)
                                          op: Equal
                                          rhs: {($ VSub_DollarName '$warning_categories')}
                                        )
                                      ]
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:warning_func)
                                          op: Equal
                                          rhs: {(func_fatal_error)}
                                        )
                                      ]
                                    )
                                  ]
                                )
                                (case_arm
                                  pat_list: [{(Lit_Star '*')}]
                                  action: [
                                    (C {(func_fatal_error)} 
                                      {
                                        (DQ ("unsupported warning category: '") ($ VSub_Number '$1') 
                                          ("'")
                                        )
                                      }
                                    )
                                  ]
                                )
                              ]
                            )
                            (C {(shift)})
                          ]
                        )
                        (case_arm
                          pat_list: [{(--verbose)} {(-v)}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:opt_verbose)
                                  op: Equal
                                  rhs: {(Lit_Other ':')}
                                )
                              ]
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(--version)}]
                          action: [(C {(func_version)})]
                        )
                        (case_arm
                          pat_list: [
                            {(-) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\?'>)}
                            {(-h)}
                          ]
                          action: [(C {(func_usage)})]
                        )
                        (case_arm
                          pat_list: [{(--help)}]
                          action: [(C {(func_help)})]
                        )
                        (case_arm
                          pat_list: [{(--) (Lit_Star '*') (Lit_Equals '=') (Lit_Star '*')}]
                          action: [
                            (C {(func_split_equals)} {(DQ ($ VSub_DollarName '$_G_opt'))})
                            (C {(KW_Set set)} {(dummy)} 
                              {(DQ ($ VSub_DollarName '$func_split_equals_lhs'))} {(DQ ($ VSub_DollarName '$func_split_equals_rhs'))} 
                              {
                                (braced_var_sub
                                  token: <VSub_Number 1>
                                  suffix_op: 
                                    (suffix_op.Unary
                                      op_id: VTest_Plus
                                      arg_word: {(DQ ($ VSub_At '$@'))}
                                    )
                                )
                              }
                            )
                            (C {(shift)})
                          ]
                        )
                        (case_arm
                          pat_list: [{(-W) (Lit_Star '*')}]
                          action: [
                            (C {(func_split_short_opt)} {(DQ ($ VSub_DollarName '$_G_opt'))})
                            (C {(KW_Set set)} {(dummy)} 
                              {(DQ ($ VSub_DollarName '$func_split_short_opt_name'))} {(DQ ($ VSub_DollarName '$func_split_short_opt_arg'))} 
                              {
                                (braced_var_sub
                                  token: <VSub_Number 1>
                                  suffix_op: 
                                    (suffix_op.Unary
                                      op_id: VTest_Plus
                                      arg_word: {(DQ ($ VSub_At '$@'))}
                                    )
                                )
                              }
                            )
                            (C {(shift)})
                          ]
                        )
                        (case_arm
                          pat_list: [
                            {(-) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\?'>) 
                              (Lit_Star '*')
                            }
                            {(-h) (Lit_Star '*')}
                            {(-v) (Lit_Star '*')}
                            {(-x) (Lit_Star '*')}
                          ]
                          action: [
                            (C {(func_split_short_opt)} {(DQ ($ VSub_DollarName '$_G_opt'))})
                            (C {(KW_Set set)} {(dummy)} 
                              {(DQ ($ VSub_DollarName '$func_split_short_opt_name'))} {(DQ (-) ($ VSub_DollarName '$func_split_short_opt_arg'))} 
                              {
                                (braced_var_sub
                                  token: <VSub_Number 1>
                                  suffix_op: 
                                    (suffix_op.Unary
                                      op_id: VTest_Plus
                                      arg_word: {(DQ ($ VSub_At '$@'))}
                                    )
                                )
                              }
                            )
                            (C {(shift)})
                          ]
                        )
                        (case_arm
                          pat_list: [{(--)}]
                          action: [(command.ControlFlow token:<ControlFlow_Break break>)]
                        )
                        (case_arm
                          pat_list: [{(-) (Lit_Star '*')}]
                          action: [
                            (C {(func_fatal_help)} 
                              {(DQ ("unrecognised option: '") ($ VSub_DollarName '$_G_opt') ("'"))}
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(Lit_Star '*')}]
                          action: [
                            (command.Sentence
                              child: 
                                (C {(KW_Set set)} {(dummy)} {(DQ ($ VSub_DollarName '$_G_opt'))} 
                                  {
                                    (braced_var_sub
                                      token: <VSub_Number 1>
                                      suffix_op: 
                                        (suffix_op.Unary
                                          op_id: VTest_Plus
                                          arg_word: {(DQ ($ VSub_At '$@'))}
                                        )
                                    )
                                  }
                                )
                              terminator: <Op_Semi ';'>
                            )
                            (command.Sentence
                              child: (C {(shift)})
                              terminator: <Op_Semi ';'>
                            )
                            (command.ControlFlow
                              token: <ControlFlow_Break break>
                            )
                          ]
                        )
                      ]
                    )
                  ]
                )
            )
            (C {(func_quote_for_eval)} 
              {
                (braced_var_sub
                  token: <VSub_Number 1>
                  suffix_op: (suffix_op.Unary op_id:VTest_Plus arg_word:{(DQ ($ VSub_At '$@'))})
                )
              }
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:func_parse_options_result)
                  op: Equal
                  rhs: {($ VSub_DollarName '$func_quote_for_eval_result')}
                )
              ]
            )
          ]
        )
    )
    (C {(func_hookable)} {(func_validate_options)})
    (command.ShFunction
      name: func_validate_options
      body: 
        (command.BraceGroup
          children: [
            (C {($ VSub_DollarName '$debug_cmd')})
            (command.AndOr
              ops: [Op_DPipe]
              children: [
                (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$opt_warning_types'))})
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:opt_warning_types)
                      op: Equal
                      rhs: {(DQ (' ') ($ VSub_DollarName '$warning_categories'))}
                    )
                  ]
                )
              ]
            )
            (C {(func_run_hooks)} {(func_validate_options)} 
              {
                (braced_var_sub
                  token: <VSub_Number 1>
                  suffix_op: (suffix_op.Unary op_id:VTest_Plus arg_word:{(DQ ($ VSub_At '$@'))})
                )
              }
            )
            (C {($ VSub_DollarName '$exit_cmd')} {($ VSub_DollarName '$EXIT_FAILURE')})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:func_validate_options_result)
                  op: Equal
                  rhs: {($ VSub_DollarName '$func_run_hooks_result')}
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: func_fatal_help
      body: 
        (command.BraceGroup
          children: [
            (C {($ VSub_DollarName '$debug_cmd')})
            (C {(eval)} {(word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) (ECHO)} 
              {(word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) 
                (DQ ('Usage: ') ($ VSub_DollarName '$usage')) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>)
              }
            )
            (C {(eval)} {(word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) (ECHO)} 
              {(word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) 
                (DQ ($ VSub_DollarName '$fatal_help')) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>)
              }
            )
            (C {(func_error)} 
              {
                (braced_var_sub
                  token: <VSub_Number 1>
                  suffix_op: (suffix_op.Unary op_id:VTest_Plus arg_word:{(DQ ($ VSub_At '$@'))})
                )
              }
            )
            (command.ControlFlow
              token: <ControlFlow_Exit exit>
              arg_word: {($ VSub_DollarName '$EXIT_FAILURE')}
            )
          ]
        )
    )
    (command.ShFunction
      name: func_help
      body: 
        (command.BraceGroup
          children: [
            (C {($ VSub_DollarName '$debug_cmd')})
            (C {(func_usage_message)})
            (C {($ VSub_DollarName '$ECHO')} {(DQ ($ VSub_DollarName '$long_help_message'))})
            (command.ControlFlow token:<ControlFlow_Exit exit> arg_word:{(0)})
          ]
        )
    )
    (command.ShFunction
      name: func_missing_arg
      body: 
        (command.BraceGroup
          children: [
            (C {($ VSub_DollarName '$debug_cmd')})
            (C {(func_error)} {(DQ ("Missing argument for '") ($ VSub_Number '$1') ("'."))})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:exit_cmd)
                  op: Equal
                  rhs: {(ControlFlow_Exit exit)}
                )
              ]
            )
          ]
        )
    )
    (command.AndOr
      ops: [Op_DAmp Op_DAmp]
      children: [
        (C {(test)} {(-z)} {(DQ ($ VSub_DollarName '$_G_HAVE_XSI_OPS'))})
        (command.Subshell
          command_list: 
            (command.CommandList
              children: [
                (C {(eval)} 
                  {
                    (SQ <'x=a/b/c;\n'> 
                      <'      test 5aa/bb/cc = "${#x}${x%%/*}${x%/*}${x#*/}${x##*/}"'>
                    )
                  }
                )
              ]
            )
          redirects: [(redir.Redir op:<Redir_Great '2>'> fd:2 arg_word:{(/dev/null)})]
        )
        (command.ShAssignment
          pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:_G_HAVE_XSI_OPS) op:Equal rhs:{(yes)})]
        )
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: [(C {(test)} {(yes)} {(Lit_Equals '=')} {(DQ ($ VSub_DollarName '$_G_HAVE_XSI_OPS'))})]
          action: [
            (C {(eval)} 
              {
                (SQ <'func_split_equals ()\n'> <'  {\n'> <'      $debug_cmd\n'> <'\n'> 
                  <'      func_split_equals_lhs=${1%%=*}\n'> <'      func_split_equals_rhs=${1#*=}\n'> <'      test "x$func_split_equals_lhs" = "x$1" \\\n'> 
                  <'        && func_split_equals_rhs=\n'> <'  }'>
                )
              }
            )
          ]
        )
      ]
      else_action: [
        (command.ShFunction
          name: func_split_equals
          body: 
            (command.BraceGroup
              children: [
                (C {($ VSub_DollarName '$debug_cmd')})
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:func_split_equals_lhs)
                      op: Equal
                      rhs: 
                        {
                          (command_sub
                            left_token: <Left_Backtick '`'>
                            command_list: 
                              (command.CommandList
                                children: [
                                  (C {(expr)} {(DQ (x) ($ VSub_Number '$1'))} {(Lit_Other ':')} 
                                    {(SQ <'x\\([^=]*\\)'>)}
                                  )
                                ]
                              )
                          )
                        }
                    )
                  ]
                )
                (command.ShAssignment
                  pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:func_split_equals_rhs) op:Equal rhs:(word.Empty))]
                )
                (command.AndOr
                  ops: [Op_DPipe]
                  children: [
                    (C {(test)} {(DQ (x) ($ VSub_DollarName '$func_split_equals_lhs'))} 
                      {(Lit_Equals '=')} {(DQ (x) ($ VSub_Number '$1'))}
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:func_split_equals_rhs)
                          op: Equal
                          rhs: 
                            {
                              (command_sub
                                left_token: <Left_Backtick '`'>
                                command_list: 
                                  (command.CommandList
                                    children: [
                                      (C {(expr)} {(DQ (x) ($ VSub_Number '$1'))} {(Lit_Other ':')} 
                                        {(SQ <'x[^=]*=\\(.*\\)$'>)}
                                      )
                                    ]
                                  )
                              )
                            }
                        )
                      ]
                    )
                  ]
                )
              ]
            )
        )
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: [(C {(test)} {(yes)} {(Lit_Equals '=')} {(DQ ($ VSub_DollarName '$_G_HAVE_XSI_OPS'))})]
          action: [
            (C {(eval)} 
              {
                (SQ <'func_split_short_opt ()\n'> <'  {\n'> <'      $debug_cmd\n'> <'\n'> 
                  <'      func_split_short_opt_arg=${1#??}\n'> <'      func_split_short_opt_name=${1%"$func_split_short_opt_arg"}\n'> <'  }'>
                )
              }
            )
          ]
        )
      ]
      else_action: [
        (command.ShFunction
          name: func_split_short_opt
          body: 
            (command.BraceGroup
              children: [
                (C {($ VSub_DollarName '$debug_cmd')})
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:func_split_short_opt_name)
                      op: Equal
                      rhs: 
                        {
                          (command_sub
                            left_token: <Left_Backtick '`'>
                            command_list: 
                              (command.CommandList
                                children: [
                                  (C {(expr)} {(DQ (x) ($ VSub_Number '$1'))} {(Lit_Other ':')} 
                                    {(SQ <'x-\\(.\\)'>)}
                                  )
                                ]
                              )
                          )
                        }
                    )
                  ]
                )
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:func_split_short_opt_arg)
                      op: Equal
                      rhs: 
                        {
                          (command_sub
                            left_token: <Left_Backtick '`'>
                            command_list: 
                              (command.CommandList
                                children: [
                                  (C {(expr)} {(DQ (x) ($ VSub_Number '$1'))} {(Lit_Other ':')} 
                                    {(SQ <'x-.\\(.*\\)$'>)}
                                  )
                                ]
                              )
                          )
                        }
                    )
                  ]
                )
              ]
            )
        )
      ]
    )
    (command.ShFunction
      name: func_usage
      body: 
        (command.BraceGroup
          children: [
            (C {($ VSub_DollarName '$debug_cmd')})
            (C {(func_usage_message)})
            (C {($ VSub_DollarName '$ECHO')} 
              {
                (DQ ("Run '") ($ VSub_DollarName '$progname') (' --help |') 
                  (braced_var_sub
                    token: <VSub_Name PAGER>
                    suffix_op: (suffix_op.Unary op_id:VTest_Hyphen arg_word:{(more)})
                  ) ("' for full usage")
                )
              }
            )
            (command.ControlFlow token:<ControlFlow_Exit exit> arg_word:{(0)})
          ]
        )
    )
    (command.ShFunction
      name: func_usage_message
      body: 
        (command.BraceGroup
          children: [
            (C {($ VSub_DollarName '$debug_cmd')})
            (C {(eval)} {(word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) (ECHO)} 
              {(word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) 
                (DQ ('Usage: ') ($ VSub_DollarName '$usage')) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>)
              }
            )
            (C {(echo)})
            (command.Simple
              words: [
                {($ VSub_DollarName '$SED')}
                {(-n)}
                {
                  (SQ <'s|^# ||\n'> <'        /^Written by/{\n'> <'          x;p;x\n'> <'        }\n'> 
                    <'\th\n'> <'\t/^Written by/q'>
                  )
                }
              ]
              redirects: [
                (redir.Redir
                  op: <Redir_Less '<'>
                  fd: 16777215
                  arg_word: {(DQ ($ VSub_DollarName '$progpath'))}
                )
              ]
            )
            (C {(echo)})
            (C {(eval)} {(word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) (ECHO)} 
              {(word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) 
                (DQ ($ VSub_DollarName '$usage_message')) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>)
              }
            )
          ]
        )
    )
    (command.ShFunction
      name: func_version
      body: 
        (command.BraceGroup
          children: [
            (C {($ VSub_DollarName '$debug_cmd')})
            (C {(printf)} {(SQ <'%s\\n'>)} 
              {(DQ ($ VSub_DollarName '$progname') (' ') ($ VSub_DollarName '$scriptversion'))}
            )
            (command.Simple
              words: [
                {($ VSub_DollarName '$SED')}
                {(-n)}
                {
                  (SQ <'\n'> <'        /(C)/!b go\n'> <'        :more\n'> <'        /\\./!{\n'> 
                    <'          N\n'> <'          s|\\n# | |\n'> <'          b more\n'> <'        }\n'> <'        :go\n'> 
                    <'        /^# Written by /,/# warranty; / {\n'> <'          s|^# ||\n'> <'          s|^# *$||\n'> 
                    <'          s|\\((C)\\)[ 0-9,-]*[ ,-]\\([1-9][0-9]* \\)|\\1 \\2|\n'> <'          p\n'> <'        }\n'> <'        /^# Written by / {\n'> <'          s|^# ||\n'> 
                    <'          p\n'> <'        }\n'> <'        /^warranty; /q'>
                  )
                }
              ]
              redirects: [
                (redir.Redir
                  op: <Redir_Less '<'>
                  fd: 16777215
                  arg_word: {(DQ ($ VSub_DollarName '$progpath'))}
                )
              ]
            )
            (command.ControlFlow
              token: <ControlFlow_Exit exit>
              arg_word: {($ VSub_QMark '$?')}
            )
          ]
        )
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:scriptversion)
          op: Equal
          rhs: {(SQ <'(GNU libtool) 2.4.6'>)}
        )
      ]
    )
    (command.ShFunction
      name: func_echo
      body: 
        (command.BraceGroup
          children: [
            (C {($ VSub_DollarName '$debug_cmd')})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:_G_message)
                  op: Equal
                  rhs: {($ VSub_Star '$*')}
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:func_echo_IFS)
                  op: Equal
                  rhs: {($ VSub_DollarName '$IFS')}
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:IFS)
                  op: Equal
                  rhs: {($ VSub_DollarName '$nl')}
                )
              ]
            )
            (command.ForEach
              iter_name: _G_line
              iter_words: [{($ VSub_DollarName '$_G_message')}]
              do_arg_iter: F
              body: 
                (command.DoGroup
                  children: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:IFS)
                          op: Equal
                          rhs: {($ VSub_DollarName '$func_echo_IFS')}
                        )
                      ]
                    )
                    (C {($ VSub_DollarName '$ECHO')} 
                      {
                        (DQ ($ VSub_DollarName '$progname') 
                          (braced_var_sub
                            token: <VSub_Name opt_mode>
                            suffix_op: 
                              (suffix_op.Unary
                                op_id: VTest_Plus
                                arg_word: {(': ') ($ VSub_DollarName '$opt_mode')}
                              )
                          ) (': ') ($ VSub_DollarName '$_G_line')
                        )
                      }
                    )
                  ]
                )
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:IFS)
                  op: Equal
                  rhs: {($ VSub_DollarName '$func_echo_IFS')}
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: func_warning
      body: 
        (command.BraceGroup
          children: [
            (C {($ VSub_DollarName '$debug_cmd')})
            (C {($ VSub_DollarName '$warning_func')} 
              {
                (braced_var_sub
                  token: <VSub_Number 1>
                  suffix_op: (suffix_op.Unary op_id:VTest_Plus arg_word:{(DQ ($ VSub_At '$@'))})
                )
              }
            )
          ]
        )
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:usage)
          op: Equal
          rhs: {(SQ <'$progpath [OPTION]... [MODE-ARG]...'>)}
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:usage_message)
          op: Equal
          rhs: 
            {
              (DQ ('Options:\n') ('       --config             show all configuration variables\n') 
                ('       --debug              enable verbose shell tracing\n') ('   -n, --dry-run            display commands without modifying any files\n') 
                ('       --features           display basic configuration information and exit\n') ('       --mode=MODE          use operation mode MODE\n') 
                ("       --no-warnings        equivalent to '-Wnone'\n") ("       --preserve-dup-deps  don't remove duplicate dependency libraries\n") 
                ("       --quiet, --silent    don't print informational messages\n") ('       --tag=TAG            use configuration variables from tag TAG\n') 
                ('   -v, --verbose            print more informational messages than default\n') ('       --version            print version information\n') 
                ('   -W, --warnings=CATEGORY  report the warnings falling in CATEGORY [all]\n') ('   -h, --help, --help-all   print short, long, or detailed help message\n')
              )
            }
        )
      ]
    )
    (command.ShFunction
      name: func_help
      body: 
        (command.BraceGroup
          children: [
            (C {($ VSub_DollarName '$debug_cmd')})
            (C {(func_usage_message)})
            (C {($ VSub_DollarName '$ECHO')} 
              {
                (DQ ($ VSub_DollarName '$long_help_message') ('\n') ('\n') 
                  ('MODE must be one of the following:\n') ('\n') ('       clean           remove files from the build directory\n') 
                  ('       compile         compile a source file into a libtool object\n') ('       execute         automatically set library path, then run a program\n') 
                  ('       finish          complete the installation of libtool libraries\n') ('       install         install libraries or executables\n') 
                  ('       link            create a library or an executable\n') ('       uninstall       remove libraries from an installed directory\n') ('\n') 
                  ('MODE-ARGS vary depending on the MODE.  When passed as first option,\n') ("'--mode=MODE' may be abbreviated as 'MODE' or a unique abbreviation of that.\n") ("Try '") 
                  ($ VSub_DollarName '$progname') (" --help --mode=MODE' for a more detailed description of MODE.\n") ('\n') 
                  ('When reporting a bug, please describe a test case to reproduce it and\n') ('include the following information:\n') ('\n') ('       host-triplet:   ') ($ VSub_DollarName '$host') 
                  ('\n') ('       shell:          ') ($ VSub_DollarName '$SHELL') ('\n') ('       compiler:       ') 
                  ($ VSub_DollarName '$LTCC') ('\n') ('       compiler flags: ') ($ VSub_DollarName '$LTCFLAGS') ('\n') ('       linker:         ') 
                  ($ VSub_DollarName '$LD') (' (gnu? ') ($ VSub_DollarName '$with_gnu_ld') (')\n') ('       version:        ') 
                  ($ VSub_DollarName '$progname') (' (GNU libtool) 2.4.6\n') ('       automake:       ') 
                  (command_sub
                    left_token: <Left_Backtick '`'>
                    command_list: 
                      (command.CommandList
                        children: [
                          (command.Pipeline
                            children: [
                              (command.Subshell
                                command_list: 
                                  (command.CommandList
                                    children: [(C {($ VSub_DollarName '$AUTOMAKE')} {(--version)})]
                                  )
                                redirects: [
                                  (redir.Redir
                                    op: <Redir_Great '2>'>
                                    fd: 2
                                    arg_word: {(/dev/null)}
                                  )
                                ]
                              )
                              (C {($ VSub_DollarName '$SED')} {(1q)})
                            ]
                            negated: F
                          )
                        ]
                      )
                  ) ('\n') ('       autoconf:       ') 
                  (command_sub
                    left_token: <Left_Backtick '`'>
                    command_list: 
                      (command.CommandList
                        children: [
                          (command.Pipeline
                            children: [
                              (command.Subshell
                                command_list: 
                                  (command.CommandList
                                    children: [(C {($ VSub_DollarName '$AUTOCONF')} {(--version)})]
                                  )
                                redirects: [
                                  (redir.Redir
                                    op: <Redir_Great '2>'>
                                    fd: 2
                                    arg_word: {(/dev/null)}
                                  )
                                ]
                              )
                              (C {($ VSub_DollarName '$SED')} {(1q)})
                            ]
                            negated: F
                          )
                        ]
                      )
                  ) ('\n') ('\n') ('Report bugs to <bug-libtool@gnu.org>.\n') 
                  ('GNU libtool home page: <http://www.gnu.org/s/libtool/>.\n') ('General help using GNU software: <http://www.gnu.org/gethelp/>.')
                )
              }
            )
            (command.ControlFlow token:<ControlFlow_Exit exit> arg_word:{(0)})
          ]
        )
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:lo2o)
          op: Equal
          rhs: 
            {(s/) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\\\'>) (.lo) 
              (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) (/.) ($ VSub_DollarName '$objext') (/)
            }
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:o2lo)
          op: Equal
          rhs: 
            {(s/) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\\\'>) (.) 
              ($ VSub_DollarName '$objext') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) (/.lo/)
            }
        )
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: [
            (command.Sentence
              child: 
                (C {(test)} {(yes)} {(Lit_Equals '=')} {(DQ ($ VSub_DollarName '$_G_HAVE_XSI_OPS'))})
              terminator: <Op_Semi ';'>
            )
          ]
          action: [
            (C {(eval)} 
              {
                (SQ <'func_lo2o ()\n'> <'  {\n'> <'    case $1 in\n'> 
                  <'      *.lo) func_lo2o_result=${1%.lo}.$objext ;;\n'> <'      *   ) func_lo2o_result=$1               ;;\n'> <'    esac\n'> <'  }'>
                )
              }
            )
            (C {(eval)} 
              {(SQ <'func_xform ()\n'> <'  {\n'> <'    func_xform_result=${1%.*}.lo\n'> <'  }'>)}
            )
          ]
        )
      ]
      else_action: [
        (command.ShFunction
          name: func_lo2o
          body: 
            (command.BraceGroup
              children: [
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:func_lo2o_result)
                      op: Equal
                      rhs: 
                        {
                          (command_sub
                            left_token: <Left_Backtick '`'>
                            command_list: 
                              (command.CommandList
                                children: [
                                  (command.Pipeline
                                    children: [
                                      (C {($ VSub_DollarName '$ECHO')} {(DQ ($ VSub_Number '$1'))})
                                      (C {($ VSub_DollarName '$SED')} {(DQ ($ VSub_DollarName '$lo2o'))})
                                    ]
                                    negated: F
                                  )
                                ]
                              )
                          )
                        }
                    )
                  ]
                )
              ]
            )
        )
        (command.ShFunction
          name: func_xform
          body: 
            (command.BraceGroup
              children: [
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:func_xform_result)
                      op: Equal
                      rhs: 
                        {
                          (command_sub
                            left_token: <Left_Backtick '`'>
                            command_list: 
                              (command.CommandList
                                children: [
                                  (command.Pipeline
                                    children: [
                                      (C {($ VSub_DollarName '$ECHO')} {(DQ ($ VSub_Number '$1'))})
                                      (C {($ VSub_DollarName '$SED')} {(SQ <'s|\\.[^.]*$|.lo|'>)})
                                    ]
                                    negated: F
                                  )
                                ]
                              )
                          )
                        }
                    )
                  ]
                )
              ]
            )
        )
      ]
    )
    (command.ShFunction
      name: func_fatal_configuration
      body: 
        (command.BraceGroup
          children: [
            (C {(func__fatal_error)} 
              {
                (braced_var_sub
                  token: <VSub_Number 1>
                  suffix_op: (suffix_op.Unary op_id:VTest_Plus arg_word:{(DQ ($ VSub_At '$@'))})
                )
              } {(DQ ('See the ') ($ VSub_DollarName '$PACKAGE') (' documentation for more information.'))} 
              {(DQ ('Fatal configuration error.'))}
            )
          ]
        )
    )
    (command.ShFunction
      name: func_config
      body: 
        (command.BraceGroup
          children: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:re_begincf)
                  op: Equal
                  rhs: {(SQ <'^# ### BEGIN LIBTOOL'>)}
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:re_endcf)
                  op: Equal
                  rhs: {(SQ <'^# ### END LIBTOOL'>)}
                )
              ]
            )
            (command.Simple
              words: [
                {($ VSub_DollarName '$SED')}
                {
                  (DQ ('1,/') ($ VSub_DollarName '$re_begincf') (' CONFIG/d;/') 
                    ($ VSub_DollarName '$re_endcf') (' CONFIG/,') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) (d)
                  )
                }
              ]
              redirects: [
                (redir.Redir
                  op: <Redir_Less '<'>
                  fd: 16777215
                  arg_word: {(DQ ($ VSub_DollarName '$progpath'))}
                )
              ]
            )
            (command.ForEach
              iter_name: tagname
              iter_words: [{($ VSub_DollarName '$taglist')}]
              do_arg_iter: F
              body: 
                (command.DoGroup
                  children: [
                    (command.Simple
                      words: [
                        {($ VSub_DollarName '$SED')}
                        {(-n)}
                        {
                          (DQ (/) ($ VSub_DollarName '$re_begincf') (' TAG CONFIG: ') 
                            ($ VSub_DollarName '$tagname') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) ('/,/') ($ VSub_DollarName '$re_endcf') 
                            (' TAG CONFIG: ') ($ VSub_DollarName '$tagname') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) (/p)
                          )
                        }
                      ]
                      redirects: [
                        (redir.Redir
                          op: <Redir_Less '<'>
                          fd: 16777215
                          arg_word: {(DQ ($ VSub_DollarName '$progpath'))}
                        )
                      ]
                    )
                  ]
                )
            )
            (command.ControlFlow
              token: <ControlFlow_Exit exit>
              arg_word: {($ VSub_QMark '$?')}
            )
          ]
        )
    )
    (command.ShFunction
      name: func_features
      body: 
        (command.BraceGroup
          children: [
            (C {(echo)} {(DQ ('host: ') ($ VSub_DollarName '$host'))})
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: 
                        (C {(test)} {(yes)} {(Lit_Equals '=')} 
                          {(DQ ($ VSub_DollarName '$build_libtool_libs'))}
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [(C {(echo)} {(DQ ('enable shared libraries'))})]
                )
              ]
              else_action: [(C {(echo)} {(DQ ('disable shared libraries'))})]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: 
                        (C {(test)} {(yes)} {(Lit_Equals '=')} 
                          {(DQ ($ VSub_DollarName '$build_old_libs'))}
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [(C {(echo)} {(DQ ('enable static libraries'))})]
                )
              ]
              else_action: [(C {(echo)} {(DQ ('disable static libraries'))})]
            )
            (command.ControlFlow
              token: <ControlFlow_Exit exit>
              arg_word: {($ VSub_QMark '$?')}
            )
          ]
        )
    )
    (command.ShFunction
      name: func_enable_tag
      body: 
        (command.BraceGroup
          children: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:tagname)
                  op: Equal
                  rhs: {($ VSub_Number '$1')}
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:re_begincf)
                  op: Equal
                  rhs: 
                    {
                      (DQ ('^# ### BEGIN LIBTOOL TAG CONFIG: ') ($ VSub_DollarName '$tagname') 
                        (word_part.EscapedLiteral
                          token: <Lit_EscapedChar '\\$'>
                        )
                      )
                    }
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:re_endcf)
                  op: Equal
                  rhs: 
                    {
                      (DQ ('^# ### END LIBTOOL TAG CONFIG: ') ($ VSub_DollarName '$tagname') 
                        (word_part.EscapedLiteral
                          token: <Lit_EscapedChar '\\$'>
                        )
                      )
                    }
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:sed_extractcf)
                  op: Equal
                  rhs: 
                    {(/) ($ VSub_DollarName '$re_begincf') (/) (Lit_Comma ',') (/) 
                      ($ VSub_DollarName '$re_endcf') (/p)
                    }
                )
              ]
            )
            (command.Case
              to_match: {($ VSub_DollarName '$tagname')}
              arms: [
                (case_arm
                  pat_list: [
                    {(Lit_Star '*') (Lit_LBracket '[') (KW_Bang '!') (-_A-Za-z0-9) (Lit_Comma ',') (/) 
                      (Lit_RBracket ']') (Lit_Star '*')
                    }
                  ]
                  action: [
                    (C {(func_fatal_error)} {(DQ ('invalid tag name: ') ($ VSub_DollarName '$tagname'))})
                  ]
                )
              ]
            )
            (command.Case
              to_match: {($ VSub_DollarName '$tagname')}
              arms: [
                (case_arm pat_list:[{(CC)}])
                (case_arm
                  pat_list: [{(Lit_Star '*')}]
                  action: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: 
                                (command.Simple
                                  words: [
                                    {($ VSub_DollarName '$GREP')}
                                    {(DQ ($ VSub_DollarName '$re_begincf'))}
                                    {(DQ ($ VSub_DollarName '$progpath'))}
                                  ]
                                  redirects: [
                                    (redir.Redir
                                      op: <Redir_Great '>'>
                                      fd: 16777215
                                      arg_word: {(/dev/null)}
                                    )
                                    (redir.Redir
                                      op: <Redir_GreatAnd '2>&'>
                                      fd: 2
                                      arg_word: {(1)}
                                    )
                                  ]
                                )
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:taglist)
                                  op: Equal
                                  rhs: 
                                    {
                                      (DQ ($ VSub_DollarName '$taglist') (' ') 
                                        ($ VSub_DollarName '$tagname')
                                      )
                                    }
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:extractedcf)
                                  op: Equal
                                  rhs: 
                                    {
                                      (command_sub
                                        left_token: <Left_Backtick '`'>
                                        command_list: 
                                          (command.CommandList
                                            children: [
                                              (command.Simple
                                                words: [
                                                  {($ VSub_DollarName '$SED')}
                                                  {(-n)}
                                                  {(-e)}
                                                  {(DQ ($ VSub_DollarName '$sed_extractcf'))}
                                                ]
                                                redirects: [
                                                  (redir.Redir
                                                    op: <Redir_Less '<'>
                                                    fd: 16777215
                                                    arg_word: {(DQ ($ VSub_DollarName '$progpath'))}
                                                  )
                                                ]
                                              )
                                            ]
                                          )
                                      )
                                    }
                                )
                              ]
                            )
                            (C {(eval)} {(DQ ($ VSub_DollarName '$extractedcf'))})
                          ]
                        )
                      ]
                      else_action: [
                        (C {(func_error)} 
                          {(DQ ('ignoring unknown tag ') ($ VSub_DollarName '$tagname'))}
                        )
                      ]
                    )
                  ]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: func_check_version_match
      body: 
        (command.BraceGroup
          children: [
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: 
                        (C {(test)} {(DQ ($ VSub_DollarName '$package_revision'))} 
                          {(KW_Bang '!') (Lit_Equals '=')} {(DQ ($ VSub_DollarName '$macro_revision'))}
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: 
                                (C {(test)} {(DQ ($ VSub_DollarName '$VERSION'))} 
                                  {(KW_Bang '!') (Lit_Equals '=')} {(DQ ($ VSub_DollarName '$macro_version'))}
                                )
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (C {(test)} {(-z)} {(DQ ($ VSub_DollarName '$macro_version'))})
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (command.Simple
                                      words: [{(cat)}]
                                      redirects: [
                                        (redir.Redir
                                          op: <Redir_GreatAnd '>&'>
                                          fd: 16777215
                                          arg_word: {(2)}
                                        )
                                        (redir.HereDoc
                                          op: <Redir_DLess '<<'>
                                          fd: 16777215
                                          here_begin: {(_LT_EOF)}
                                          here_end_span_id: 10000
                                          stdin_parts: [
                                            ($ VSub_DollarName '$progname')
                                            (': Version mismatch error.  This is ')
                                            ($ VSub_DollarName '$PACKAGE')
                                            (' ')
                                            ($ VSub_DollarName '$VERSION')
                                            (', but the\n')
                                            ($ VSub_DollarName '$progname')
                                            (
': definition of this LT_INIT comes from an older release.\n'
                                            )
                                            ($ VSub_DollarName '$progname')
                                            (': You should recreate aclocal.m4 with macros from ')
                                            ($ VSub_DollarName '$PACKAGE')
                                            (' ')
                                            ($ VSub_DollarName '$VERSION')
                                            ('\n')
                                            ($ VSub_DollarName '$progname')
                                            (': and run autoconf again.\n')
                                          ]
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                              else_action: [
                                (command.Simple
                                  words: [{(cat)}]
                                  redirects: [
                                    (redir.Redir
                                      op: <Redir_GreatAnd '>&'>
                                      fd: 16777215
                                      arg_word: {(2)}
                                    )
                                    (redir.HereDoc
                                      op: <Redir_DLess '<<'>
                                      fd: 16777215
                                      here_begin: {(_LT_EOF)}
                                      here_end_span_id: 10034
                                      stdin_parts: [
                                        ($ VSub_DollarName '$progname')
                                        (': Version mismatch error.  This is ')
                                        ($ VSub_DollarName '$PACKAGE')
                                        (' ')
                                        ($ VSub_DollarName '$VERSION')
                                        (', but the\n')
                                        ($ VSub_DollarName '$progname')
                                        (': definition of this LT_INIT comes from ')
                                        ($ VSub_DollarName '$PACKAGE')
                                        (' ')
                                        ($ VSub_DollarName '$macro_version')
                                        ('.\n')
                                        ($ VSub_DollarName '$progname')
                                        (': You should recreate aclocal.m4 with macros from ')
                                        ($ VSub_DollarName '$PACKAGE')
                                        (' ')
                                        ($ VSub_DollarName '$VERSION')
                                        ('\n')
                                        ($ VSub_DollarName '$progname')
                                        (': and run autoconf again.\n')
                                      ]
                                    )
                                  ]
                                )
                              ]
                            )
                          ]
                        )
                      ]
                      else_action: [
                        (command.Simple
                          words: [{(cat)}]
                          redirects: [
                            (redir.Redir
                              op: <Redir_GreatAnd '>&'>
                              fd: 16777215
                              arg_word: {(2)}
                            )
                            (redir.HereDoc
                              op: <Redir_DLess '<<'>
                              fd: 16777215
                              here_begin: {(_LT_EOF)}
                              here_end_span_id: 10073
                              stdin_parts: [
                                ($ VSub_DollarName '$progname')
                                (': Version mismatch error.  This is ')
                                ($ VSub_DollarName '$PACKAGE')
                                (' ')
                                ($ VSub_DollarName '$VERSION')
                                (', revision ')
                                ($ VSub_DollarName '$package_revision')
                                (',\n')
                                ($ VSub_DollarName '$progname')
                                (': but the definition of this LT_INIT comes from revision ')
                                ($ VSub_DollarName '$macro_revision')
                                ('.\n')
                                ($ VSub_DollarName '$progname')
                                (': You should recreate aclocal.m4 with macros from revision ')
                                ($ VSub_DollarName '$package_revision')
                                ('\n')
                                ($ VSub_DollarName '$progname')
                                (': of ')
                                ($ VSub_DollarName '$PACKAGE')
                                (' ')
                                ($ VSub_DollarName '$VERSION')
                                (' and run autoconf again.\n')
                              ]
                            )
                          ]
                        )
                      ]
                    )
                    (command.ControlFlow
                      token: <ControlFlow_Exit exit>
                      arg_word: {($ VSub_DollarName '$EXIT_MISMATCH')}
                    )
                  ]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: libtool_options_prep
      body: 
        (command.BraceGroup
          children: [
            (C {($ VSub_DollarName '$debug_mode')})
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:opt_config) op:Equal rhs:{(false)})]
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:opt_dlopen) op:Equal rhs:(word.Empty))]
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:opt_dry_run) op:Equal rhs:{(false)})]
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:opt_help) op:Equal rhs:{(false)})]
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:opt_mode) op:Equal rhs:(word.Empty))]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:opt_preserve_dup_deps)
                  op: Equal
                  rhs: {(false)}
                )
              ]
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:opt_quiet) op:Equal rhs:{(false)})]
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:nonopt) op:Equal rhs:(word.Empty))]
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:preserve_args) op:Equal rhs:(word.Empty))]
            )
            (command.Case
              to_match: {($ VSub_Number '$1')}
              arms: [
                (case_arm
                  pat_list: [{(clean)} {(clea)} {(cle)} {(cl)}]
                  action: [
                    (command.Sentence
                      child: (C {(shift)})
                      terminator: <Op_Semi ';'>
                    )
                    (command.Sentence
                      child: 
                        (C {(KW_Set set)} {(dummy)} {(--mode)} {(clean)} 
                          {
                            (braced_var_sub
                              token: <VSub_Number 1>
                              suffix_op: 
                                (suffix_op.Unary
                                  op_id: VTest_Plus
                                  arg_word: {(DQ ($ VSub_At '$@'))}
                                )
                            )
                          }
                        )
                      terminator: <Op_Semi ';'>
                    )
                    (C {(shift)})
                  ]
                )
                (case_arm
                  pat_list: [{(compile)} {(compil)} {(compi)} {(comp)} {(com)} {(co)} {(c)}]
                  action: [
                    (command.Sentence
                      child: (C {(shift)})
                      terminator: <Op_Semi ';'>
                    )
                    (command.Sentence
                      child: 
                        (C {(KW_Set set)} {(dummy)} {(--mode)} {(compile)} 
                          {
                            (braced_var_sub
                              token: <VSub_Number 1>
                              suffix_op: 
                                (suffix_op.Unary
                                  op_id: VTest_Plus
                                  arg_word: {(DQ ($ VSub_At '$@'))}
                                )
                            )
                          }
                        )
                      terminator: <Op_Semi ';'>
                    )
                    (C {(shift)})
                  ]
                )
                (case_arm
                  pat_list: [{(execute)} {(execut)} {(execu)} {(exec)} {(exe)} {(ex)} {(e)}]
                  action: [
                    (command.Sentence
                      child: (C {(shift)})
                      terminator: <Op_Semi ';'>
                    )
                    (command.Sentence
                      child: 
                        (C {(KW_Set set)} {(dummy)} {(--mode)} {(execute)} 
                          {
                            (braced_var_sub
                              token: <VSub_Number 1>
                              suffix_op: 
                                (suffix_op.Unary
                                  op_id: VTest_Plus
                                  arg_word: {(DQ ($ VSub_At '$@'))}
                                )
                            )
                          }
                        )
                      terminator: <Op_Semi ';'>
                    )
                    (C {(shift)})
                  ]
                )
                (case_arm
                  pat_list: [{(finish)} {(finis)} {(fini)} {(fin)} {(KW_Fi fi)} {(f)}]
                  action: [
                    (command.Sentence
                      child: (C {(shift)})
                      terminator: <Op_Semi ';'>
                    )
                    (command.Sentence
                      child: 
                        (C {(KW_Set set)} {(dummy)} {(--mode)} {(finish)} 
                          {
                            (braced_var_sub
                              token: <VSub_Number 1>
                              suffix_op: 
                                (suffix_op.Unary
                                  op_id: VTest_Plus
                                  arg_word: {(DQ ($ VSub_At '$@'))}
                                )
                            )
                          }
                        )
                      terminator: <Op_Semi ';'>
                    )
                    (C {(shift)})
                  ]
                )
                (case_arm
                  pat_list: [{(install)} {(instal)} {(insta)} {(inst)} {(ins)} {(KW_In in)} {(i)}]
                  action: [
                    (command.Sentence
                      child: (C {(shift)})
                      terminator: <Op_Semi ';'>
                    )
                    (command.Sentence
                      child: 
                        (C {(KW_Set set)} {(dummy)} {(--mode)} {(install)} 
                          {
                            (braced_var_sub
                              token: <VSub_Number 1>
                              suffix_op: 
                                (suffix_op.Unary
                                  op_id: VTest_Plus
                                  arg_word: {(DQ ($ VSub_At '$@'))}
                                )
                            )
                          }
                        )
                      terminator: <Op_Semi ';'>
                    )
                    (C {(shift)})
                  ]
                )
                (case_arm
                  pat_list: [{(link)} {(lin)} {(li)} {(l)}]
                  action: [
                    (command.Sentence
                      child: (C {(shift)})
                      terminator: <Op_Semi ';'>
                    )
                    (command.Sentence
                      child: 
                        (C {(KW_Set set)} {(dummy)} {(--mode)} {(link)} 
                          {
                            (braced_var_sub
                              token: <VSub_Number 1>
                              suffix_op: 
                                (suffix_op.Unary
                                  op_id: VTest_Plus
                                  arg_word: {(DQ ($ VSub_At '$@'))}
                                )
                            )
                          }
                        )
                      terminator: <Op_Semi ';'>
                    )
                    (C {(shift)})
                  ]
                )
                (case_arm
                  pat_list: [
                    {(uninstall)}
                    {(uninstal)}
                    {(uninsta)}
                    {(uninst)}
                    {(unins)}
                    {(unin)}
                    {(uni)}
                    {(un)}
                    {(u)}
                  ]
                  action: [
                    (command.Sentence
                      child: (C {(shift)})
                      terminator: <Op_Semi ';'>
                    )
                    (command.Sentence
                      child: 
                        (C {(KW_Set set)} {(dummy)} {(--mode)} {(uninstall)} 
                          {
                            (braced_var_sub
                              token: <VSub_Number 1>
                              suffix_op: 
                                (suffix_op.Unary
                                  op_id: VTest_Plus
                                  arg_word: {(DQ ($ VSub_At '$@'))}
                                )
                            )
                          }
                        )
                      terminator: <Op_Semi ';'>
                    )
                    (C {(shift)})
                  ]
                )
              ]
            )
            (C {(func_quote_for_eval)} 
              {
                (braced_var_sub
                  token: <VSub_Number 1>
                  suffix_op: (suffix_op.Unary op_id:VTest_Plus arg_word:{(DQ ($ VSub_At '$@'))})
                )
              }
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:libtool_options_prep_result)
                  op: Equal
                  rhs: {($ VSub_DollarName '$func_quote_for_eval_result')}
                )
              ]
            )
          ]
        )
    )
    (C {(func_add_hook)} {(func_options_prep)} {(libtool_options_prep)})
    (command.ShFunction
      name: libtool_parse_options
      body: 
        (command.BraceGroup
          children: [
            (C {($ VSub_DollarName '$debug_cmd')})
            (command.WhileUntil
              keyword: <KW_While while>
              cond: [
                (command.Sentence
                  child: (C {(test)} {($ VSub_Pound '$#')} {(-gt)} {(0)})
                  terminator: <Op_Semi ';'>
                )
              ]
              body: 
                (command.DoGroup
                  children: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:_G_opt)
                          op: Equal
                          rhs: {($ VSub_Number '$1')}
                        )
                      ]
                    )
                    (C {(shift)})
                    (command.Case
                      to_match: {($ VSub_DollarName '$_G_opt')}
                      arms: [
                        (case_arm
                          pat_list: [{(--dry-run)} {(--dryrun)} {(-n)}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:opt_dry_run)
                                  op: Equal
                                  rhs: {(Lit_Other ':')}
                                )
                              ]
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(--config)}]
                          action: [(C {(func_config)})]
                        )
                        (case_arm
                          pat_list: [{(--dlopen)} {(-dlopen)}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:opt_dlopen)
                                  op: Equal
                                  rhs: 
                                    {
                                      (DQ 
                                        (braced_var_sub
                                          token: <VSub_Name opt_dlopen>
                                          suffix_op: 
                                            (suffix_op.Unary
                                              op_id: VTest_Plus
                                              arg_word: {($ VSub_DollarName '$opt_dlopen') ('\n')}
                                            )
                                        ) ($ VSub_Number '$1')
                                      )
                                    }
                                )
                              ]
                            )
                            (C {(shift)})
                          ]
                        )
                        (case_arm
                          pat_list: [{(--preserve-dup-deps)}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:opt_preserve_dup_deps)
                                  op: Equal
                                  rhs: {(Lit_Other ':')}
                                )
                              ]
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(--features)}]
                          action: [(C {(func_features)})]
                        )
                        (case_arm
                          pat_list: [{(--finish)}]
                          action: [
                            (command.Sentence
                              child: 
                                (C {(KW_Set set)} {(dummy)} {(--mode)} {(finish)} 
                                  {
                                    (braced_var_sub
                                      token: <VSub_Number 1>
                                      suffix_op: 
                                        (suffix_op.Unary
                                          op_id: VTest_Plus
                                          arg_word: {(DQ ($ VSub_At '$@'))}
                                        )
                                    )
                                  }
                                )
                              terminator: <Op_Semi ';'>
                            )
                            (C {(shift)})
                          ]
                        )
                        (case_arm
                          pat_list: [{(--help)}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:opt_help)
                                  op: Equal
                                  rhs: {(Lit_Other ':')}
                                )
                              ]
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(--help-all)}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:opt_help)
                                  op: Equal
                                  rhs: {(SQ <': help-all'>)}
                                )
                              ]
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(--mode)}]
                          action: [
                            (command.AndOr
                              ops: [Op_DAmp Op_DAmp]
                              children: [
                                (C {(test)} {($ VSub_Pound '$#')} {(Lit_Equals '=')} {(0)})
                                (C {(func_missing_arg)} {($ VSub_DollarName '$_G_opt')})
                                (command.ControlFlow
                                  token: <ControlFlow_Break break>
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:opt_mode)
                                  op: Equal
                                  rhs: {($ VSub_Number '$1')}
                                )
                              ]
                            )
                            (command.Case
                              to_match: {($ VSub_Number '$1')}
                              arms: [
                                (case_arm
                                  pat_list: [
                                    {(clean)}
                                    {(compile)}
                                    {(execute)}
                                    {(finish)}
                                    {(install)}
                                    {(link)}
                                    {(relink)}
                                    {(uninstall)}
                                  ]
                                )
                                (case_arm
                                  pat_list: [{(Lit_Star '*')}]
                                  action: [
                                    (C {(func_error)} 
                                      {(DQ ('invalid argument for ') ($ VSub_DollarName '$_G_opt'))}
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:exit_cmd)
                                          op: Equal
                                          rhs: {(ControlFlow_Exit exit)}
                                        )
                                      ]
                                    )
                                    (command.ControlFlow
                                      token: <ControlFlow_Break break>
                                    )
                                  ]
                                )
                              ]
                            )
                            (C {(shift)})
                          ]
                        )
                        (case_arm
                          pat_list: [{(--no-silent)} {(--no-quiet)}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:opt_quiet)
                                  op: Equal
                                  rhs: {(false)}
                                )
                              ]
                            )
                            (C {(func_append)} {(preserve_args)} 
                              {(DQ (' ') ($ VSub_DollarName '$_G_opt'))}
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(--no-warnings)} {(--no-warning)} {(--no-warn)}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:opt_warning)
                                  op: Equal
                                  rhs: {(false)}
                                )
                              ]
                            )
                            (C {(func_append)} {(preserve_args)} 
                              {(DQ (' ') ($ VSub_DollarName '$_G_opt'))}
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(--no-verbose)}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:opt_verbose)
                                  op: Equal
                                  rhs: {(false)}
                                )
                              ]
                            )
                            (C {(func_append)} {(preserve_args)} 
                              {(DQ (' ') ($ VSub_DollarName '$_G_opt'))}
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(--silent)} {(--quiet)}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:opt_quiet)
                                  op: Equal
                                  rhs: {(Lit_Other ':')}
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:opt_verbose)
                                  op: Equal
                                  rhs: {(false)}
                                )
                              ]
                            )
                            (C {(func_append)} {(preserve_args)} 
                              {(DQ (' ') ($ VSub_DollarName '$_G_opt'))}
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(--tag)}]
                          action: [
                            (command.AndOr
                              ops: [Op_DAmp Op_DAmp]
                              children: [
                                (C {(test)} {($ VSub_Pound '$#')} {(Lit_Equals '=')} {(0)})
                                (C {(func_missing_arg)} {($ VSub_DollarName '$_G_opt')})
                                (command.ControlFlow
                                  token: <ControlFlow_Break break>
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:opt_tag)
                                  op: Equal
                                  rhs: {($ VSub_Number '$1')}
                                )
                              ]
                            )
                            (C {(func_append)} {(preserve_args)} 
                              {(DQ (' ') ($ VSub_DollarName '$_G_opt') (' ') ($ VSub_Number '$1'))}
                            )
                            (C {(func_enable_tag)} {(DQ ($ VSub_Number '$1'))})
                            (C {(shift)})
                          ]
                        )
                        (case_arm
                          pat_list: [{(--verbose)} {(-v)}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:opt_quiet)
                                  op: Equal
                                  rhs: {(false)}
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:opt_verbose)
                                  op: Equal
                                  rhs: {(Lit_Other ':')}
                                )
                              ]
                            )
                            (C {(func_append)} {(preserve_args)} 
                              {(DQ (' ') ($ VSub_DollarName '$_G_opt'))}
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(Lit_Star '*')}]
                          action: [
                            (command.Sentence
                              child: 
                                (C {(KW_Set set)} {(dummy)} {(DQ ($ VSub_DollarName '$_G_opt'))} 
                                  {
                                    (braced_var_sub
                                      token: <VSub_Number 1>
                                      suffix_op: 
                                        (suffix_op.Unary
                                          op_id: VTest_Plus
                                          arg_word: {(DQ ($ VSub_At '$@'))}
                                        )
                                    )
                                  }
                                )
                              terminator: <Op_Semi ';'>
                            )
                            (command.Sentence
                              child: (C {(shift)})
                              terminator: <Op_Semi ';'>
                            )
                            (command.ControlFlow
                              token: <ControlFlow_Break break>
                            )
                          ]
                        )
                      ]
                    )
                  ]
                )
            )
            (C {(func_quote_for_eval)} 
              {
                (braced_var_sub
                  token: <VSub_Number 1>
                  suffix_op: (suffix_op.Unary op_id:VTest_Plus arg_word:{(DQ ($ VSub_At '$@'))})
                )
              }
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:libtool_parse_options_result)
                  op: Equal
                  rhs: {($ VSub_DollarName '$func_quote_for_eval_result')}
                )
              ]
            )
          ]
        )
    )
    (C {(func_add_hook)} {(func_parse_options)} {(libtool_parse_options)})
    (command.ShFunction
      name: libtool_validate_options
      body: 
        (command.BraceGroup
          children: [
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: (C {(test)} {(0)} {(-lt)} {($ VSub_Pound '$#')})
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:nonopt)
                          op: Equal
                          rhs: {($ VSub_Number '$1')}
                        )
                      ]
                    )
                    (C {(shift)})
                  ]
                )
              ]
            )
            (command.AndOr
              ops: [Op_DPipe]
              children: [
                (C {(test)} {(Lit_Other ':')} {(Lit_Equals '=')} {(DQ ($ VSub_DollarName '$debug_cmd'))})
                (C {(func_append)} {(preserve_args)} {(DQ (' --debug'))})
              ]
            )
            (command.Case
              to_match: {($ VSub_DollarName '$host')}
              arms: [
                (case_arm
                  pat_list: [
                    {(Lit_Star '*') (cygwin) (Lit_Star '*')}
                    {(Lit_Star '*') (mingw) (Lit_Star '*')}
                    {(Lit_Star '*') (pw32) (Lit_Star '*')}
                    {(Lit_Star '*') (cegcc) (Lit_Star '*')}
                    {(Lit_Star '*') (solaris2) (Lit_Star '*')}
                    {(Lit_Star '*') (os2) (Lit_Star '*')}
                  ]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:opt_duplicate_compiler_generated_deps)
                          op: Equal
                          rhs: {(Lit_Other ':')}
                        )
                      ]
                    )
                  ]
                )
                (case_arm
                  pat_list: [{(Lit_Star '*')}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:opt_duplicate_compiler_generated_deps)
                          op: Equal
                          rhs: {($ VSub_DollarName '$opt_preserve_dup_deps')}
                        )
                      ]
                    )
                  ]
                )
              ]
            )
            (command.AndOr
              ops: [Op_DPipe]
              children: [
                (C {($ VSub_DollarName '$opt_help')})
                (command.BraceGroup
                  children: [
                    (C {(func_check_version_match)})
                    (command.AndOr
                      ops: [Op_DAmp Op_DAmp]
                      children: [
                        (C {(test)} {(yes)} {(KW_Bang '!') (Lit_Equals '=')} 
                          {(DQ ($ VSub_DollarName '$build_libtool_libs'))}
                        )
                        (C {(test)} {(yes)} {(KW_Bang '!') (Lit_Equals '=')} 
                          {(DQ ($ VSub_DollarName '$build_old_libs'))}
                        )
                        (C {(func_fatal_configuration)} 
                          {(DQ ('not configured to build any kind of library'))}
                        )
                      ]
                    )
                    (C {(eval)} 
                      {(Lit_VarLike 'std_shrext=') 
                        (word_part.EscapedLiteral
                          token: <Lit_EscapedChar '\\"'>
                        ) ($ VSub_DollarName '$shrext_cmds') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>)
                      }
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: 
                                (command.AndOr
                                  ops: [Op_DAmp]
                                  children: [
                                    (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$opt_dlopen'))})
                                    (C {(test)} {(execute)} {(KW_Bang '!') (Lit_Equals '=')} 
                                      {(DQ ($ VSub_DollarName '$opt_mode'))}
                                    )
                                  ]
                                )
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [
                            (C {(func_error)} {(DQ ("unrecognized option '-dlopen'"))})
                            (command.Simple
                              words: [{($ VSub_DollarName '$ECHO')} {(DQ ($ VSub_DollarName '$help'))}]
                              redirects: [(redir.Redir op:<Redir_GreatAnd '1>&'> fd:1 arg_word:{(2)})]
                            )
                            (command.ControlFlow
                              token: <ControlFlow_Exit exit>
                              arg_word: {($ VSub_DollarName '$EXIT_FAILURE')}
                            )
                          ]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:generic_help)
                          op: Equal
                          rhs: {($ VSub_DollarName '$help')}
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:help)
                          op: Equal
                          rhs: 
                            {
                              (DQ ("Try '") ($ VSub_DollarName '$progname') (' --help --mode=') 
                                ($ VSub_DollarName '$opt_mode') ("' for more information.")
                              )
                            }
                        )
                      ]
                    )
                  ]
                )
              ]
            )
            (C {(func_quote_for_eval)} 
              {
                (braced_var_sub
                  token: <VSub_Number 1>
                  suffix_op: (suffix_op.Unary op_id:VTest_Plus arg_word:{(DQ ($ VSub_At '$@'))})
                )
              }
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:libtool_validate_options_result)
                  op: Equal
                  rhs: {($ VSub_DollarName '$func_quote_for_eval_result')}
                )
              ]
            )
          ]
        )
    )
    (C {(func_add_hook)} {(func_validate_options)} {(libtool_validate_options)})
    (C {(func_options)} 
      {
        (braced_var_sub
          token: <VSub_Number 1>
          suffix_op: (suffix_op.Unary op_id:VTest_Plus arg_word:{(DQ ($ VSub_At '$@'))})
        )
      }
    )
    (command.CommandList
      children: [
        (command.Sentence
          child: (C {(eval)} {(KW_Set set)} {(dummy)} {(DQ ($ VSub_DollarName '$func_options_result'))})
          terminator: <Op_Semi ';'>
        )
        (C {(shift)})
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:magic)
          op: Equal
          rhs: {(SQ <'%%%MAGIC variable%%%'>)}
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:magic_exe)
          op: Equal
          rhs: {(SQ <'%%%MAGIC EXE variable%%%'>)}
        )
      ]
    )
    (command.ShAssignment
      pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:extracted_archives) op:Equal rhs:(word.Empty))]
    )
    (command.ShAssignment
      pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:extracted_serial) op:Equal rhs:{(0)})]
    )
    (command.ShAssignment
      pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:exec_cmd) op:Equal rhs:(word.Empty))]
    )
    (command.ShFunction
      name: func_fallback_echo
      body: 
        (command.BraceGroup
          children: [(C {(eval)} {(SQ <'cat <<_LTECHO_EOF\n'> <'$1\n'> <_LTECHO_EOF>)})]
        )
    )
    (command.ShFunction
      name: func_generated_by_libtool_p
      body: 
        (command.BraceGroup
          children: [
            (command.Simple
              words: [
                {($ VSub_DollarName '$GREP')}
                {(DQ ('^# Generated by .*') ($ VSub_DollarName '$PACKAGE'))}
              ]
              redirects: [
                (redir.Redir op:<Redir_Great '>'> fd:16777215 arg_word:{(/dev/null)})
                (redir.Redir op:<Redir_GreatAnd '2>&'> fd:2 arg_word:{(1)})
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: func_lalib_p
      body: 
        (command.BraceGroup
          children: [
            (command.AndOr
              ops: [Op_DAmp]
              children: [
                (C {(test)} {(-f)} {(DQ ($ VSub_Number '$1'))})
                (command.Pipeline
                  children: [
                    (command.Simple
                      words: [{($ VSub_DollarName '$SED')} {(-e)} {(4q)} {(DQ ($ VSub_Number '$1'))}]
                      redirects: [(redir.Redir op:<Redir_Great '2>'> fd:2 arg_word:{(/dev/null)})]
                    )
                    (C {(func_generated_by_libtool_p)})
                  ]
                  negated: F
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: func_lalib_unsafe_p
      body: 
        (command.BraceGroup
          children: [
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:lalib_p) op:Equal rhs:{(no)})]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: 
                        (command.AndOr
                          ops: [Op_DAmp Op_DAmp]
                          children: [
                            (C {(test)} {(-f)} {(DQ ($ VSub_Number '$1'))})
                            (C {(test)} {(-r)} {(DQ ($ VSub_Number '$1'))})
                            (command.Simple
                              words: [{(exec)}]
                              redirects: [
                                (redir.Redir
                                  op: <Redir_LessAnd '5<&'>
                                  fd: 5
                                  arg_word: {(0)}
                                )
                                (redir.Redir
                                  op: <Redir_Less '<'>
                                  fd: 16777215
                                  arg_word: {(DQ ($ VSub_Number '$1'))}
                                )
                              ]
                            )
                          ]
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (command.ForEach
                      iter_name: lalib_p_l
                      iter_words: [{(1)} {(2)} {(3)} {(4)}]
                      do_arg_iter: F
                      body: 
                        (command.DoGroup
                          children: [
                            (C {(read)} {(lalib_p_line)})
                            (command.Case
                              to_match: {($ VSub_DollarName '$lalib_p_line')}
                              arms: [
                                (case_arm
                                  pat_list: [
                                    {(word_part.EscapedLiteral token:<Lit_EscapedChar '\\#'>) 
                                      (word_part.EscapedLiteral
                                        token: <Lit_EscapedChar '\\ '>
                                      ) (Generated) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\ '>) (by) 
                                      (word_part.EscapedLiteral
                                        token: <Lit_EscapedChar '\\ '>
                                      ) (Lit_Star '*') ($ VSub_DollarName '$PACKAGE') (Lit_Star '*')
                                    }
                                  ]
                                  action: [
                                    (command.Sentence
                                      child: 
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:lalib_p)
                                              op: Equal
                                              rhs: {(yes)}
                                            )
                                          ]
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                    (command.ControlFlow
                                      token: <ControlFlow_Break break>
                                    )
                                  ]
                                )
                              ]
                            )
                          ]
                        )
                    )
                    (command.Simple
                      words: [{(exec)}]
                      redirects: [
                        (redir.Redir
                          op: <Redir_LessAnd '0<&'>
                          fd: 0
                          arg_word: {(5)}
                        )
                        (redir.Redir
                          op: <Redir_LessAnd '5<&'>
                          fd: 5
                          arg_word: {(-)}
                        )
                      ]
                    )
                  ]
                )
              ]
            )
            (C {(test)} {(yes)} {(Lit_Equals '=')} {(DQ ($ VSub_DollarName '$lalib_p'))})
          ]
        )
    )
    (command.ShFunction
      name: func_ltwrapper_script_p
      body: 
        (command.BraceGroup
          children: [
            (command.AndOr
              ops: [Op_DAmp]
              children: [
                (C {(test)} {(-f)} {(DQ ($ VSub_Number '$1'))})
                (command.Pipeline
                  children: [
                    (command.Simple
                      words: [{($ VSub_DollarName '$lt_truncate_bin')}]
                      redirects: [
                        (redir.Redir
                          op: <Redir_Less '<'>
                          fd: 16777215
                          arg_word: {(DQ ($ VSub_Number '$1'))}
                        )
                        (redir.Redir
                          op: <Redir_Great '2>'>
                          fd: 2
                          arg_word: {(/dev/null)}
                        )
                      ]
                    )
                    (C {(func_generated_by_libtool_p)})
                  ]
                  negated: F
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: func_ltwrapper_executable_p
      body: 
        (command.BraceGroup
          children: [
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:func_ltwrapper_exec_suffix) op:Equal rhs:(word.Empty))]
            )
            (command.Case
              to_match: {($ VSub_Number '$1')}
              arms: [
                (case_arm pat_list:[{(Lit_Star '*') (.exe)}])
                (case_arm
                  pat_list: [{(Lit_Star '*')}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:func_ltwrapper_exec_suffix)
                          op: Equal
                          rhs: {(.exe)}
                        )
                      ]
                    )
                  ]
                )
              ]
            )
            (command.Simple
              words: [
                {($ VSub_DollarName '$GREP')}
                {(DQ ($ VSub_DollarName '$magic_exe'))}
                {(DQ ($ VSub_Number '$1') ($ VSub_DollarName '$func_ltwrapper_exec_suffix'))}
              ]
              redirects: [
                (redir.Redir op:<Redir_Great '>'> fd:16777215 arg_word:{(/dev/null)})
                (redir.Redir op:<Redir_GreatAnd '2>&'> fd:2 arg_word:{(1)})
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: func_ltwrapper_scriptname
      body: 
        (command.BraceGroup
          children: [
            (C {(func_dirname_and_basename)} {(DQ ($ VSub_Number '$1'))} {(DQ )} {(DQ (.))})
            (C {(func_stripname)} {(SQ )} {(SQ <.exe>)} {(DQ ($ VSub_DollarName '$func_basename_result'))})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:func_ltwrapper_scriptname_result)
                  op: Equal
                  rhs: 
                    {($ VSub_DollarName '$func_dirname_result') (/) ($ VSub_DollarName '$objdir') (/) 
                      (${ VSub_Name func_stripname_result) (_ltshwrapper)
                    }
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: func_ltwrapper_p
      body: 
        (command.BraceGroup
          children: [
            (command.AndOr
              ops: [Op_DPipe]
              children: [
                (C {(func_ltwrapper_script_p)} {(DQ ($ VSub_Number '$1'))})
                (C {(func_ltwrapper_executable_p)} {(DQ ($ VSub_Number '$1'))})
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: func_execute_cmds
      body: 
        (command.BraceGroup
          children: [
            (C {($ VSub_DollarName '$debug_cmd')})
            (command.Sentence
              child: 
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:save_ifs)
                      op: Equal
                      rhs: {($ VSub_DollarName '$IFS')}
                    )
                  ]
                )
              terminator: <Op_Semi ';'>
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:IFS) op:Equal rhs:{(SQ <'~'>)})]
            )
            (command.ForEach
              iter_name: cmd
              iter_words: [{($ VSub_Number '$1')}]
              do_arg_iter: F
              body: 
                (command.DoGroup
                  children: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:IFS)
                          op: Equal
                          rhs: {($ VSub_DollarName '$sp') ($ VSub_DollarName '$nl')}
                        )
                      ]
                    )
                    (C {(eval)} 
                      {(Lit_VarLike 'cmd=') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) 
                        ($ VSub_DollarName '$cmd') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>)
                      }
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:IFS)
                          op: Equal
                          rhs: {($ VSub_DollarName '$save_ifs')}
                        )
                      ]
                    )
                    (C {(func_show_eval)} {(DQ ($ VSub_DollarName '$cmd'))} 
                      {
                        (DQ 
                          (braced_var_sub
                            token: <VSub_Number 2>
                            suffix_op: (suffix_op.Unary op_id:VTest_Hyphen arg_word:{(':')})
                          )
                        )
                      }
                    )
                  ]
                )
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:IFS)
                  op: Equal
                  rhs: {($ VSub_DollarName '$save_ifs')}
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: func_source
      body: 
        (command.BraceGroup
          children: [
            (C {($ VSub_DollarName '$debug_cmd')})
            (command.Case
              to_match: {($ VSub_Number '$1')}
              arms: [
                (case_arm
                  pat_list: [
                    {(Lit_Star '*') (/) (Lit_Star '*')}
                    {(Lit_Star '*') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\\\'>) 
                      (Lit_Star '*')
                    }
                  ]
                  action: [(C {(.)} {(DQ ($ VSub_Number '$1'))})]
                )
                (case_arm
                  pat_list: [{(Lit_Star '*')}]
                  action: [(C {(.)} {(DQ (./) ($ VSub_Number '$1'))})]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: func_resolve_sysroot
      body: 
        (command.BraceGroup
          children: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:func_resolve_sysroot_result)
                  op: Equal
                  rhs: {($ VSub_Number '$1')}
                )
              ]
            )
            (command.Case
              to_match: {($ VSub_DollarName '$func_resolve_sysroot_result')}
              arms: [
                (case_arm
                  pat_list: [{(Lit_Equals '=') (Lit_Star '*')}]
                  action: [
                    (C {(func_stripname)} {(SQ <'='>)} {(SQ )} 
                      {(DQ ($ VSub_DollarName '$func_resolve_sysroot_result'))}
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:func_resolve_sysroot_result)
                          op: Equal
                          rhs: 
                            {($ VSub_DollarName '$lt_sysroot') 
                              ($ VSub_DollarName '$func_stripname_result')
                            }
                        )
                      ]
                    )
                  ]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: func_replace_sysroot
      body: 
        (command.BraceGroup
          children: [
            (command.Case
              to_match: {($ VSub_DollarName '$lt_sysroot') (Lit_Other ':') ($ VSub_Number '$1')}
              arms: [
                (case_arm
                  pat_list: [
                    {(Lit_QMark '?') (Lit_Star '*') (Lit_Other ':') 
                      (DQ ($ VSub_DollarName '$lt_sysroot')) (Lit_Star '*')
                    }
                  ]
                  action: [
                    (C {(func_stripname)} {(DQ ($ VSub_DollarName '$lt_sysroot'))} {(SQ )} 
                      {(DQ ($ VSub_Number '$1'))}
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:func_replace_sysroot_result)
                          op: Equal
                          rhs: {(SQ <'='>) ($ VSub_DollarName '$func_stripname_result')}
                        )
                      ]
                    )
                  ]
                )
                (case_arm
                  pat_list: [{(Lit_Star '*')}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:func_replace_sysroot_result)
                          op: Equal
                          rhs: {($ VSub_Number '$1')}
                        )
                      ]
                    )
                  ]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: func_infer_tag
      body: 
        (command.BraceGroup
          children: [
            (C {($ VSub_DollarName '$debug_cmd')})
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: 
                        (command.AndOr
                          ops: [Op_DAmp]
                          children: [
                            (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$available_tags'))})
                            (C {(test)} {(-z)} {(DQ ($ VSub_DollarName '$tagname'))})
                          ]
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (command.ShAssignment
                      pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:CC_quoted) op:Equal rhs:(word.Empty))]
                    )
                    (command.ForEach
                      iter_name: arg
                      iter_words: [{($ VSub_DollarName '$CC')}]
                      do_arg_iter: F
                      body: 
                        (command.DoGroup
                          children: [
                            (C {(func_append_quoted)} {(CC_quoted)} {(DQ ($ VSub_DollarName '$arg'))})
                          ]
                        )
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:CC_expanded)
                          op: Equal
                          rhs: 
                            {
                              (command_sub
                                left_token: <Left_Backtick '`'>
                                command_list: 
                                  (command.CommandList
                                    children: [(C {(func_echo_all)} {($ VSub_DollarName '$CC')})]
                                  )
                              )
                            }
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:CC_quoted_expanded)
                          op: Equal
                          rhs: 
                            {
                              (command_sub
                                left_token: <Left_Backtick '`'>
                                command_list: 
                                  (command.CommandList
                                    children: [(C {(func_echo_all)} {($ VSub_DollarName '$CC_quoted')})]
                                  )
                              )
                            }
                        )
                      ]
                    )
                    (command.Case
                      to_match: {($ VSub_At '$@')}
                      arms: [
                        (case_arm
                          pat_list: [
                            {(DQ (' ') ($ VSub_DollarName '$CC') (' ')) (Lit_Star '*')}
                            {(DQ ($ VSub_DollarName '$CC') (' ')) (Lit_Star '*')}
                            {(DQ (' ') ($ VSub_DollarName '$CC_expanded') (' ')) (Lit_Star '*')}
                            {(DQ ($ VSub_DollarName '$CC_expanded') (' ')) (Lit_Star '*')}
                            {(DQ (' ') ($ VSub_DollarName '$CC_quoted')) (Lit_Star '*')}
                            {(DQ ($ VSub_DollarName '$CC_quoted') (' ')) (Lit_Star '*')}
                            {(DQ (' ') ($ VSub_DollarName '$CC_quoted_expanded') (' ')) 
                              (Lit_Star '*')
                            }
                            {(DQ ($ VSub_DollarName '$CC_quoted_expanded') (' ')) (Lit_Star '*')}
                          ]
                        )
                        (case_arm
                          pat_list: [{(Lit_Star '*')}]
                          action: [
                            (command.ForEach
                              iter_name: z
                              iter_words: [{($ VSub_DollarName '$available_tags')}]
                              do_arg_iter: F
                              body: 
                                (command.DoGroup
                                  children: [
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (command.Sentence
                                              child: 
                                                (command.Simple
                                                  words: [
                                                    {($ VSub_DollarName '$GREP')}
                                                    {
                                                      (DQ ('^# ### BEGIN LIBTOOL TAG CONFIG: ') 
                                                        ($ VSub_DollarName '$z') (Lit_Other '$')
                                                      )
                                                    }
                                                  ]
                                                  redirects: [
                                                    (redir.Redir
                                                      op: <Redir_Less '<'>
                                                      fd: 16777215
                                                      arg_word: {(DQ ($ VSub_DollarName '$progpath'))}
                                                    )
                                                    (redir.Redir
                                                      op: <Redir_Great '>'>
                                                      fd: 16777215
                                                      arg_word: {(/dev/null)}
                                                    )
                                                  ]
                                                )
                                              terminator: <Op_Semi ';'>
                                            )
                                          ]
                                          action: [
                                            (C {(eval)} 
                                              {
                                                (DQ 
                                                  (command_sub
                                                    left_token: <Left_Backtick '`'>
                                                    command_list: 
                                                      (command.CommandList
                                                        children: [
                                                          (command.Simple
                                                            words: [
                                                              {($ VSub_DollarName '$SED')}
                                                              {(-n)}
                                                              {(-e)}
                                                              {
                                                                (SQ 
                                                                  <
'/^# ### BEGIN LIBTOOL TAG CONFIG: '
                                                                  >
                                                                ) ($ VSub_DollarName '$z') (SQ <'$/,/^# ### END LIBTOOL TAG CONFIG: '>) ($ VSub_DollarName '$z') 
                                                                (SQ <'$/p'>)
                                                              }
                                                            ]
                                                            redirects: [
                                                              (redir.Redir
                                                                op: <Redir_Less '<'>
                                                                fd: 16777215
                                                                arg_word: 
                                                                  {($ VSub_DollarName '$progpath')}
                                                              )
                                                            ]
                                                          )
                                                        ]
                                                      )
                                                  )
                                                )
                                              }
                                            )
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:CC_quoted)
                                                  op: Equal
                                                  rhs: (word.Empty)
                                                )
                                              ]
                                            )
                                            (command.ForEach
                                              iter_name: arg
                                              iter_words: [{($ VSub_DollarName '$CC')}]
                                              do_arg_iter: F
                                              body: 
                                                (command.DoGroup
                                                  children: [
                                                    (C {(func_append_quoted)} {(CC_quoted)} 
                                                      {(DQ ($ VSub_DollarName '$arg'))}
                                                    )
                                                  ]
                                                )
                                            )
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:CC_expanded)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (command_sub
                                                        left_token: <Left_Backtick '`'>
                                                        command_list: 
                                                          (command.CommandList
                                                            children: [
                                                              (C {(func_echo_all)} 
                                                                {($ VSub_DollarName '$CC')}
                                                              )
                                                            ]
                                                          )
                                                      )
                                                    }
                                                )
                                              ]
                                            )
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:CC_quoted_expanded)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (command_sub
                                                        left_token: <Left_Backtick '`'>
                                                        command_list: 
                                                          (command.CommandList
                                                            children: [
                                                              (C {(func_echo_all)} 
                                                                {($ VSub_DollarName '$CC_quoted')}
                                                              )
                                                            ]
                                                          )
                                                      )
                                                    }
                                                )
                                              ]
                                            )
                                            (command.Case
                                              to_match: {(DQ ($ VSub_At '$@') (' '))}
                                              arms: [
                                                (case_arm
                                                  pat_list: [
                                                    {(DQ (' ') ($ VSub_DollarName '$CC') (' ')) 
                                                      (Lit_Star '*')
                                                    }
                                                    {(DQ ($ VSub_DollarName '$CC') (' ')) 
                                                      (Lit_Star '*')
                                                    }
                                                    {
                                                      (DQ (' ') ($ VSub_DollarName '$CC_expanded') 
                                                        (' ')
                                                      ) (Lit_Star '*')
                                                    }
                                                    {(DQ ($ VSub_DollarName '$CC_expanded') (' ')) 
                                                      (Lit_Star '*')
                                                    }
                                                    {(DQ (' ') ($ VSub_DollarName '$CC_quoted')) 
                                                      (Lit_Star '*')
                                                    }
                                                    {(DQ ($ VSub_DollarName '$CC_quoted') (' ')) 
                                                      (Lit_Star '*')
                                                    }
                                                    {
                                                      (DQ (' ') 
                                                        ($ VSub_DollarName '$CC_quoted_expanded') (' ')
                                                      ) (Lit_Star '*')
                                                    }
                                                    {
                                                      (DQ ($ VSub_DollarName '$CC_quoted_expanded') 
                                                        (' ')
                                                      ) (Lit_Star '*')
                                                    }
                                                  ]
                                                  action: [
                                                    (command.ShAssignment
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (sh_lhs_expr.Name name:tagname)
                                                          op: Equal
                                                          rhs: {($ VSub_DollarName '$z')}
                                                        )
                                                      ]
                                                    )
                                                    (command.ControlFlow
                                                      token: <ControlFlow_Break break>
                                                    )
                                                  ]
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                  ]
                                )
                            )
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: (C {(test)} {(-z)} {(DQ ($ VSub_DollarName '$tagname'))})
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (C {(func_echo)} {(DQ ('unable to infer tagged configuration'))})
                                    (C {(func_fatal_error)} {(DQ ("specify a tag with '--tag'"))})
                                  ]
                                )
                              ]
                            )
                          ]
                        )
                      ]
                    )
                  ]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: func_write_libtool_object
      body: 
        (command.BraceGroup
          children: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:write_libobj)
                  op: Equal
                  rhs: {($ VSub_Number '$1')}
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: 
                        (C {(test)} {(yes)} {(Lit_Equals '=')} 
                          {(DQ ($ VSub_DollarName '$build_libtool_libs'))}
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:write_lobj)
                          op: Equal
                          rhs: 
                            {(word_part.EscapedLiteral token:<Lit_EscapedChar "\\'">) 
                              ($ VSub_Number '$2') (word_part.EscapedLiteral token:<Lit_EscapedChar "\\'">)
                            }
                        )
                      ]
                    )
                  ]
                )
              ]
              else_action: [
                (command.ShAssignment
                  pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:write_lobj) op:Equal rhs:{(none)})]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: 
                        (C {(test)} {(yes)} {(Lit_Equals '=')} 
                          {(DQ ($ VSub_DollarName '$build_old_libs'))}
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:write_oldobj)
                          op: Equal
                          rhs: 
                            {(word_part.EscapedLiteral token:<Lit_EscapedChar "\\'">) 
                              ($ VSub_Number '$3') (word_part.EscapedLiteral token:<Lit_EscapedChar "\\'">)
                            }
                        )
                      ]
                    )
                  ]
                )
              ]
              else_action: [
                (command.ShAssignment
                  pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:write_oldobj) op:Equal rhs:{(none)})]
                )
              ]
            )
            (command.AndOr
              ops: [Op_DPipe]
              children: [
                (C {($ VSub_DollarName '$opt_dry_run')})
                (command.BraceGroup
                  children: [
                    (command.Simple
                      words: [{(cat)}]
                      redirects: [
                        (redir.Redir
                          op: <Redir_Great '>'>
                          fd: 16777215
                          arg_word: {(${ VSub_Name write_libobj) (T)}
                        )
                        (redir.HereDoc
                          op: <Redir_DLess '<<'>
                          fd: 16777215
                          here_begin: {(EOF)}
                          here_end_span_id: 12793
                          stdin_parts: [
                            ('# ')
                            ($ VSub_DollarName '$write_libobj')
                            (' - a libtool object file\n')
                            ('# Generated by ')
                            ($ VSub_DollarName '$PROGRAM')
                            (' (GNU ')
                            ($ VSub_DollarName '$PACKAGE')
                            (') ')
                            ($ VSub_DollarName '$VERSION')
                            ('\n')
                            ('#\n')
                            ('# Please DO NOT delete this file!\n')
                            ('# It is necessary for linking the library.\n')
                            ('\n')
                            ('# Name of the PIC object.\n')
                            ('pic_object=')
                            ($ VSub_DollarName '$write_lobj')
                            ('\n')
                            ('\n')
                            ('# Name of the non-PIC object\n')
                            ('non_pic_object=')
                            ($ VSub_DollarName '$write_oldobj')
                            ('\n')
                            ('\n')
                          ]
                        )
                      ]
                    )
                    (C {($ VSub_DollarName '$MV')} {(DQ (${ VSub_Name write_libobj) (T))} 
                      {(DQ ($ VSub_DollarName '$write_libobj'))}
                    )
                  ]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: func_convert_core_file_wine_to_w32
      body: 
        (command.BraceGroup
          children: [
            (C {($ VSub_DollarName '$debug_cmd')})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:func_convert_core_file_wine_to_w32_result)
                  op: Equal
                  rhs: {($ VSub_Number '$1')}
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: (C {(test)} {(-n)} {(DQ ($ VSub_Number '$1'))})
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:func_convert_core_file_wine_to_w32_tmp)
                          op: Equal
                          rhs: 
                            {
                              (command_sub
                                left_token: <Left_Backtick '`'>
                                command_list: 
                                  (command.CommandList
                                    children: [
                                      (command.Simple
                                        words: [{(winepath)} {(-w)} {(DQ ($ VSub_Number '$1'))}]
                                        redirects: [
                                          (redir.Redir
                                            op: <Redir_Great '2>'>
                                            fd: 2
                                            arg_word: {(/dev/null)}
                                          )
                                        ]
                                      )
                                    ]
                                  )
                              )
                            }
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: 
                                (command.AndOr
                                  ops: [Op_DAmp]
                                  children: [
                                    (C {(test)} {(DQ ($ VSub_QMark '$?'))} {(-eq)} {(0)})
                                    (C {(test)} {(-n)} 
                                      {
                                        (DQ 
                                          ($ VSub_DollarName 
'$func_convert_core_file_wine_to_w32_tmp'
                                          )
                                        )
                                      }
                                    )
                                  ]
                                )
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: 
                                    (sh_lhs_expr.Name
                                      name: func_convert_core_file_wine_to_w32_result
                                    )
                                  op: Equal
                                  rhs: 
                                    {
                                      (command_sub
                                        left_token: <Left_Backtick '`'>
                                        command_list: 
                                          (command.CommandList
                                            children: [
                                              (command.Pipeline
                                                children: [
                                                  (C {($ VSub_DollarName '$ECHO')} 
                                                    {
                                                      (DQ 
                                                        ($ VSub_DollarName 
'$func_convert_core_file_wine_to_w32_tmp'
                                                        )
                                                      )
                                                    }
                                                  )
                                                  (C {($ VSub_DollarName '$SED')} {(-e)} 
                                                    {
                                                      (DQ 
                                                        ($ VSub_DollarName '$sed_naive_backslashify')
                                                      )
                                                    }
                                                  )
                                                ]
                                                negated: F
                                              )
                                            ]
                                          )
                                      )
                                    }
                                )
                              ]
                            )
                          ]
                        )
                      ]
                      else_action: [
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:func_convert_core_file_wine_to_w32_result)
                              op: Equal
                              rhs: (word.Empty)
                            )
                          ]
                        )
                      ]
                    )
                  ]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: func_convert_core_path_wine_to_w32
      body: 
        (command.BraceGroup
          children: [
            (C {($ VSub_DollarName '$debug_cmd')})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:func_convert_core_path_wine_to_w32_result)
                  op: Equal
                  rhs: (word.Empty)
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: (C {(test)} {(-n)} {(DQ ($ VSub_Number '$1'))})
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:oldIFS)
                          op: Equal
                          rhs: {($ VSub_DollarName '$IFS')}
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:IFS)
                          op: Equal
                          rhs: {(Lit_Other ':')}
                        )
                      ]
                    )
                    (command.ForEach
                      iter_name: func_convert_core_path_wine_to_w32_f
                      iter_words: [{($ VSub_Number '$1')}]
                      do_arg_iter: F
                      body: 
                        (command.DoGroup
                          children: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:IFS)
                                  op: Equal
                                  rhs: {($ VSub_DollarName '$oldIFS')}
                                )
                              ]
                            )
                            (C {(func_convert_core_file_wine_to_w32)} 
                              {(DQ ($ VSub_DollarName '$func_convert_core_path_wine_to_w32_f'))}
                            )
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (C {(test)} {(-n)} 
                                          {
                                            (DQ 
                                              ($ VSub_DollarName 
'$func_convert_core_file_wine_to_w32_result'
                                              )
                                            )
                                          }
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (command.Sentence
                                              child: 
                                                (C {(test)} {(-z)} 
                                                  {
                                                    (DQ 
                                                      ($ VSub_DollarName 
'$func_convert_core_path_wine_to_w32_result'
                                                      )
                                                    )
                                                  }
                                                )
                                              terminator: <Op_Semi ';'>
                                            )
                                          ]
                                          action: [
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: 
                                                    (sh_lhs_expr.Name
                                                      name: 
func_convert_core_path_wine_to_w32_result
                                                    )
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      ($ VSub_DollarName 
'$func_convert_core_file_wine_to_w32_result'
                                                      )
                                                    }
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                      ]
                                      else_action: [
                                        (C {(func_append)} 
                                          {(func_convert_core_path_wine_to_w32_result)} {(DQ (';') ($ VSub_DollarName '$func_convert_core_file_wine_to_w32_result'))}
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                            )
                          ]
                        )
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:IFS)
                          op: Equal
                          rhs: {($ VSub_DollarName '$oldIFS')}
                        )
                      ]
                    )
                  ]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: func_cygpath
      body: 
        (command.BraceGroup
          children: [
            (C {($ VSub_DollarName '$debug_cmd')})
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: 
                        (command.AndOr
                          ops: [Op_DAmp]
                          children: [
                            (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$LT_CYGPATH'))})
                            (C {(test)} {(-f)} {(DQ ($ VSub_DollarName '$LT_CYGPATH'))})
                          ]
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:func_cygpath_result)
                          op: Equal
                          rhs: 
                            {
                              (command_sub
                                left_token: <Left_Backtick '`'>
                                command_list: 
                                  (command.CommandList
                                    children: [
                                      (command.Simple
                                        words: [
                                          {($ VSub_DollarName '$LT_CYGPATH')}
                                          {(DQ ($ VSub_At '$@'))}
                                        ]
                                        redirects: [
                                          (redir.Redir
                                            op: <Redir_Great '2>'>
                                            fd: 2
                                            arg_word: {(/dev/null)}
                                          )
                                        ]
                                      )
                                    ]
                                  )
                              )
                            }
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: (C {(test)} {(DQ ($ VSub_QMark '$?'))} {(-ne)} {(0)})
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:func_cygpath_result)
                                  op: Equal
                                  rhs: (word.Empty)
                                )
                              ]
                            )
                          ]
                        )
                      ]
                    )
                  ]
                )
              ]
              else_action: [
                (command.ShAssignment
                  pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:func_cygpath_result) op:Equal rhs:(word.Empty))]
                )
                (C {(func_error)} 
                  {
                    (DQ ("LT_CYGPATH is empty or specifies non-existent file: '") 
                      ($ VSub_DollarName '$LT_CYGPATH') ("'")
                    )
                  }
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: func_convert_core_msys_to_w32
      body: 
        (command.BraceGroup
          children: [
            (C {($ VSub_DollarName '$debug_cmd')})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:func_convert_core_msys_to_w32_result)
                  op: Equal
                  rhs: 
                    {
                      (command_sub
                        left_token: <Left_Backtick '`'>
                        command_list: 
                          (command.CommandList
                            children: [
                              (command.Pipeline
                                children: [
                                  (command.Subshell
                                    command_list: 
                                      (command.CommandList
                                        children: [
                                          (C {(cmd)} {(//c)} {(echo)} {(DQ ($ VSub_Number '$1'))})
                                        ]
                                      )
                                    redirects: [
                                      (redir.Redir
                                        op: <Redir_Great '2>'>
                                        fd: 2
                                        arg_word: {(/dev/null)}
                                      )
                                    ]
                                  )
                                  (C {($ VSub_DollarName '$SED')} {(-e)} {(SQ <'s/[ ]*$//'>)} {(-e)} 
                                    {(DQ ($ VSub_DollarName '$sed_naive_backslashify'))}
                                  )
                                ]
                                negated: F
                              )
                            ]
                          )
                      )
                    }
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: func_convert_file_check
      body: 
        (command.BraceGroup
          children: [
            (C {($ VSub_DollarName '$debug_cmd')})
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: 
                        (command.AndOr
                          ops: [Op_DAmp]
                          children: [
                            (C {(test)} {(-z)} {(DQ ($ VSub_Number '$2'))})
                            (C {(test)} {(-n)} {(DQ ($ VSub_Number '$1'))})
                          ]
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (C {(func_error)} {(DQ ('Could not determine host file name corresponding to'))})
                    (C {(func_error)} {(DQ ("  '") ($ VSub_Number '$1') ("'"))})
                    (C {(func_error)} {(DQ ('Continuing, but uninstalled executables may not work.'))})
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:func_to_host_file_result)
                          op: Equal
                          rhs: {($ VSub_Number '$1')}
                        )
                      ]
                    )
                  ]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: func_convert_path_check
      body: 
        (command.BraceGroup
          children: [
            (C {($ VSub_DollarName '$debug_cmd')})
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: 
                        (command.AndOr
                          ops: [Op_DAmp]
                          children: [
                            (C {(test)} {(-z)} {(DQ ($ VSub_Number '$4'))})
                            (C {(test)} {(-n)} {(DQ ($ VSub_Number '$3'))})
                          ]
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (C {(func_error)} {(DQ ('Could not determine the host path corresponding to'))})
                    (C {(func_error)} {(DQ ("  '") ($ VSub_Number '$3') ("'"))})
                    (C {(func_error)} {(DQ ('Continuing, but uninstalled executables may not work.'))})
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: 
                                (C {(test)} {(DQ (x) ($ VSub_Number '$1'))} 
                                  {(KW_Bang '!') (Lit_Equals '=')} {(DQ (x) ($ VSub_Number '$2'))}
                                )
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:lt_replace_pathsep_chars)
                                  op: Equal
                                  rhs: 
                                    {
                                      (DQ ('s|') ($ VSub_Number '$1') ('|') ($ VSub_Number '$2') ('|g'))
                                    }
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:func_to_host_path_result)
                                  op: Equal
                                  rhs: 
                                    {
                                      (command_sub
                                        left_token: <Left_Backtick '`'>
                                        command_list: 
                                          (command.CommandList
                                            children: [
                                              (command.Pipeline
                                                children: [
                                                  (C {(echo)} {(DQ ($ VSub_Number '$3'))})
                                                  (C {($ VSub_DollarName '$SED')} {(-e)} 
                                                    {
                                                      (DQ 
                                                        ($ VSub_DollarName 
'$lt_replace_pathsep_chars'
                                                        )
                                                      )
                                                    }
                                                  )
                                                ]
                                                negated: F
                                              )
                                            ]
                                          )
                                      )
                                    }
                                )
                              ]
                            )
                          ]
                        )
                      ]
                      else_action: [
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:func_to_host_path_result)
                              op: Equal
                              rhs: {($ VSub_Number '$3')}
                            )
                          ]
                        )
                      ]
                    )
                  ]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: func_convert_path_front_back_pathsep
      body: 
        (command.BraceGroup
          children: [
            (C {($ VSub_DollarName '$debug_cmd')})
            (command.Case
              to_match: {($ VSub_Number '$4')}
              arms: [
                (case_arm
                  pat_list: [{($ VSub_Number '$1')}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:func_to_host_path_result)
                          op: Equal
                          rhs: {($ VSub_Number '$3') ($ VSub_DollarName '$func_to_host_path_result')}
                        )
                      ]
                    )
                  ]
                )
              ]
            )
            (command.Case
              to_match: {($ VSub_Number '$4')}
              arms: [
                (case_arm
                  pat_list: [{($ VSub_Number '$2')}]
                  action: [(C {(func_append)} {(func_to_host_path_result)} {(DQ ($ VSub_Number '$3'))})]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: func_to_host_file
      body: 
        (command.BraceGroup
          children: [
            (C {($ VSub_DollarName '$debug_cmd')})
            (C {($ VSub_DollarName '$to_host_file_cmd')} {(DQ ($ VSub_Number '$1'))})
          ]
        )
    )
    (command.ShFunction
      name: func_to_tool_file
      body: 
        (command.BraceGroup
          children: [
            (C {($ VSub_DollarName '$debug_cmd')})
            (command.Case
              to_match: {(Lit_Comma ',') ($ VSub_Number '$2') (Lit_Comma ',')}
              arms: [
                (case_arm
                  pat_list: [
                    {(Lit_Star '*') (Lit_Comma ',') (DQ ($ VSub_DollarName '$to_tool_file_cmd')) 
                      (Lit_Comma ',') (Lit_Star '*')
                    }
                  ]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:func_to_tool_file_result)
                          op: Equal
                          rhs: {($ VSub_Number '$1')}
                        )
                      ]
                    )
                  ]
                )
                (case_arm
                  pat_list: [{(Lit_Star '*')}]
                  action: [
                    (C {($ VSub_DollarName '$to_tool_file_cmd')} {(DQ ($ VSub_Number '$1'))})
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:func_to_tool_file_result)
                          op: Equal
                          rhs: {($ VSub_DollarName '$func_to_host_file_result')}
                        )
                      ]
                    )
                  ]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: func_convert_file_noop
      body: 
        (command.BraceGroup
          children: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:func_to_host_file_result)
                  op: Equal
                  rhs: {($ VSub_Number '$1')}
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: func_convert_file_msys_to_w32
      body: 
        (command.BraceGroup
          children: [
            (C {($ VSub_DollarName '$debug_cmd')})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:func_to_host_file_result)
                  op: Equal
                  rhs: {($ VSub_Number '$1')}
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: (C {(test)} {(-n)} {(DQ ($ VSub_Number '$1'))})
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (C {(func_convert_core_msys_to_w32)} {(DQ ($ VSub_Number '$1'))})
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:func_to_host_file_result)
                          op: Equal
                          rhs: {($ VSub_DollarName '$func_convert_core_msys_to_w32_result')}
                        )
                      ]
                    )
                  ]
                )
              ]
            )
            (C {(func_convert_file_check)} {(DQ ($ VSub_Number '$1'))} 
              {(DQ ($ VSub_DollarName '$func_to_host_file_result'))}
            )
          ]
        )
    )
    (command.ShFunction
      name: func_convert_file_cygwin_to_w32
      body: 
        (command.BraceGroup
          children: [
            (C {($ VSub_DollarName '$debug_cmd')})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:func_to_host_file_result)
                  op: Equal
                  rhs: {($ VSub_Number '$1')}
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: (C {(test)} {(-n)} {(DQ ($ VSub_Number '$1'))})
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:func_to_host_file_result)
                          op: Equal
                          rhs: 
                            {
                              (command_sub
                                left_token: <Left_Backtick '`'>
                                command_list: 
                                  (command.CommandList
                                    children: [(C {(cygpath)} {(-m)} {(DQ ($ VSub_Number '$1'))})]
                                  )
                              )
                            }
                        )
                      ]
                    )
                  ]
                )
              ]
            )
            (C {(func_convert_file_check)} {(DQ ($ VSub_Number '$1'))} 
              {(DQ ($ VSub_DollarName '$func_to_host_file_result'))}
            )
          ]
        )
    )
    (command.ShFunction
      name: func_convert_file_nix_to_w32
      body: 
        (command.BraceGroup
          children: [
            (C {($ VSub_DollarName '$debug_cmd')})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:func_to_host_file_result)
                  op: Equal
                  rhs: {($ VSub_Number '$1')}
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: (C {(test)} {(-n)} {(DQ ($ VSub_Number '$1'))})
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (C {(func_convert_core_file_wine_to_w32)} {(DQ ($ VSub_Number '$1'))})
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:func_to_host_file_result)
                          op: Equal
                          rhs: {($ VSub_DollarName '$func_convert_core_file_wine_to_w32_result')}
                        )
                      ]
                    )
                  ]
                )
              ]
            )
            (C {(func_convert_file_check)} {(DQ ($ VSub_Number '$1'))} 
              {(DQ ($ VSub_DollarName '$func_to_host_file_result'))}
            )
          ]
        )
    )
    (command.ShFunction
      name: func_convert_file_msys_to_cygwin
      body: 
        (command.BraceGroup
          children: [
            (C {($ VSub_DollarName '$debug_cmd')})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:func_to_host_file_result)
                  op: Equal
                  rhs: {($ VSub_Number '$1')}
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: (C {(test)} {(-n)} {(DQ ($ VSub_Number '$1'))})
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (C {(func_convert_core_msys_to_w32)} {(DQ ($ VSub_Number '$1'))})
                    (C {(func_cygpath)} {(-u)} 
                      {(DQ ($ VSub_DollarName '$func_convert_core_msys_to_w32_result'))}
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:func_to_host_file_result)
                          op: Equal
                          rhs: {($ VSub_DollarName '$func_cygpath_result')}
                        )
                      ]
                    )
                  ]
                )
              ]
            )
            (C {(func_convert_file_check)} {(DQ ($ VSub_Number '$1'))} 
              {(DQ ($ VSub_DollarName '$func_to_host_file_result'))}
            )
          ]
        )
    )
    (command.ShFunction
      name: func_convert_file_nix_to_cygwin
      body: 
        (command.BraceGroup
          children: [
            (C {($ VSub_DollarName '$debug_cmd')})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:func_to_host_file_result)
                  op: Equal
                  rhs: {($ VSub_Number '$1')}
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: (C {(test)} {(-n)} {(DQ ($ VSub_Number '$1'))})
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (C {(func_convert_core_file_wine_to_w32)} {(DQ ($ VSub_Number '$1'))})
                    (C {(func_cygpath)} {(-u)} 
                      {(DQ ($ VSub_DollarName '$func_convert_core_file_wine_to_w32_result'))}
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:func_to_host_file_result)
                          op: Equal
                          rhs: {($ VSub_DollarName '$func_cygpath_result')}
                        )
                      ]
                    )
                  ]
                )
              ]
            )
            (C {(func_convert_file_check)} {(DQ ($ VSub_Number '$1'))} 
              {(DQ ($ VSub_DollarName '$func_to_host_file_result'))}
            )
          ]
        )
    )
    (command.ShAssignment
      pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:to_host_path_cmd) op:Equal rhs:(word.Empty))]
    )
    (command.ShFunction
      name: func_init_to_host_path_cmd
      body: 
        (command.BraceGroup
          children: [
            (C {($ VSub_DollarName '$debug_cmd')})
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: (C {(test)} {(-z)} {(DQ ($ VSub_DollarName '$to_host_path_cmd'))})
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (C {(func_stripname)} {(SQ <func_convert_file_>)} {(SQ )} 
                      {(DQ ($ VSub_DollarName '$to_host_file_cmd'))}
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:to_host_path_cmd)
                          op: Equal
                          rhs: {(func_convert_path_) ($ VSub_DollarName '$func_stripname_result')}
                        )
                      ]
                    )
                  ]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: func_to_host_path
      body: 
        (command.BraceGroup
          children: [
            (C {($ VSub_DollarName '$debug_cmd')})
            (C {(func_init_to_host_path_cmd)})
            (C {($ VSub_DollarName '$to_host_path_cmd')} {(DQ ($ VSub_Number '$1'))})
          ]
        )
    )
    (command.ShFunction
      name: func_convert_path_noop
      body: 
        (command.BraceGroup
          children: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:func_to_host_path_result)
                  op: Equal
                  rhs: {($ VSub_Number '$1')}
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: func_convert_path_msys_to_w32
      body: 
        (command.BraceGroup
          children: [
            (C {($ VSub_DollarName '$debug_cmd')})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:func_to_host_path_result)
                  op: Equal
                  rhs: {($ VSub_Number '$1')}
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: (C {(test)} {(-n)} {(DQ ($ VSub_Number '$1'))})
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (C {(func_stripname)} {(Lit_Other ':')} {(Lit_Other ':')} {(DQ ($ VSub_Number '$1'))})
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:func_to_host_path_tmp1)
                          op: Equal
                          rhs: {($ VSub_DollarName '$func_stripname_result')}
                        )
                      ]
                    )
                    (C {(func_convert_core_msys_to_w32)} 
                      {(DQ ($ VSub_DollarName '$func_to_host_path_tmp1'))}
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:func_to_host_path_result)
                          op: Equal
                          rhs: {($ VSub_DollarName '$func_convert_core_msys_to_w32_result')}
                        )
                      ]
                    )
                    (C {(func_convert_path_check)} {(Lit_Other ':')} {(DQ (';'))} 
                      {(DQ ($ VSub_DollarName '$func_to_host_path_tmp1'))} {(DQ ($ VSub_DollarName '$func_to_host_path_result'))}
                    )
                    (C {(func_convert_path_front_back_pathsep)} {(DQ (':*'))} {(DQ ('*:'))} {(DQ (';'))} 
                      {(DQ ($ VSub_Number '$1'))}
                    )
                  ]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: func_convert_path_cygwin_to_w32
      body: 
        (command.BraceGroup
          children: [
            (C {($ VSub_DollarName '$debug_cmd')})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:func_to_host_path_result)
                  op: Equal
                  rhs: {($ VSub_Number '$1')}
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: (C {(test)} {(-n)} {(DQ ($ VSub_Number '$1'))})
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (C {(func_stripname)} {(Lit_Other ':')} {(Lit_Other ':')} {(DQ ($ VSub_Number '$1'))})
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:func_to_host_path_tmp1)
                          op: Equal
                          rhs: {($ VSub_DollarName '$func_stripname_result')}
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:func_to_host_path_result)
                          op: Equal
                          rhs: 
                            {
                              (command_sub
                                left_token: <Left_Backtick '`'>
                                command_list: 
                                  (command.CommandList
                                    children: [
                                      (C {(cygpath)} {(-m)} {(-p)} 
                                        {(DQ ($ VSub_DollarName '$func_to_host_path_tmp1'))}
                                      )
                                    ]
                                  )
                              )
                            }
                        )
                      ]
                    )
                    (C {(func_convert_path_check)} {(Lit_Other ':')} {(DQ (';'))} 
                      {(DQ ($ VSub_DollarName '$func_to_host_path_tmp1'))} {(DQ ($ VSub_DollarName '$func_to_host_path_result'))}
                    )
                    (C {(func_convert_path_front_back_pathsep)} {(DQ (':*'))} {(DQ ('*:'))} {(DQ (';'))} 
                      {(DQ ($ VSub_Number '$1'))}
                    )
                  ]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: func_convert_path_nix_to_w32
      body: 
        (command.BraceGroup
          children: [
            (C {($ VSub_DollarName '$debug_cmd')})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:func_to_host_path_result)
                  op: Equal
                  rhs: {($ VSub_Number '$1')}
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: (C {(test)} {(-n)} {(DQ ($ VSub_Number '$1'))})
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (C {(func_stripname)} {(Lit_Other ':')} {(Lit_Other ':')} {(DQ ($ VSub_Number '$1'))})
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:func_to_host_path_tmp1)
                          op: Equal
                          rhs: {($ VSub_DollarName '$func_stripname_result')}
                        )
                      ]
                    )
                    (C {(func_convert_core_path_wine_to_w32)} 
                      {(DQ ($ VSub_DollarName '$func_to_host_path_tmp1'))}
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:func_to_host_path_result)
                          op: Equal
                          rhs: {($ VSub_DollarName '$func_convert_core_path_wine_to_w32_result')}
                        )
                      ]
                    )
                    (C {(func_convert_path_check)} {(Lit_Other ':')} {(DQ (';'))} 
                      {(DQ ($ VSub_DollarName '$func_to_host_path_tmp1'))} {(DQ ($ VSub_DollarName '$func_to_host_path_result'))}
                    )
                    (C {(func_convert_path_front_back_pathsep)} {(DQ (':*'))} {(DQ ('*:'))} {(DQ (';'))} 
                      {(DQ ($ VSub_Number '$1'))}
                    )
                  ]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: func_convert_path_msys_to_cygwin
      body: 
        (command.BraceGroup
          children: [
            (C {($ VSub_DollarName '$debug_cmd')})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:func_to_host_path_result)
                  op: Equal
                  rhs: {($ VSub_Number '$1')}
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: (C {(test)} {(-n)} {(DQ ($ VSub_Number '$1'))})
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (C {(func_stripname)} {(Lit_Other ':')} {(Lit_Other ':')} {(DQ ($ VSub_Number '$1'))})
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:func_to_host_path_tmp1)
                          op: Equal
                          rhs: {($ VSub_DollarName '$func_stripname_result')}
                        )
                      ]
                    )
                    (C {(func_convert_core_msys_to_w32)} 
                      {(DQ ($ VSub_DollarName '$func_to_host_path_tmp1'))}
                    )
                    (C {(func_cygpath)} {(-u)} {(-p)} 
                      {(DQ ($ VSub_DollarName '$func_convert_core_msys_to_w32_result'))}
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:func_to_host_path_result)
                          op: Equal
                          rhs: {($ VSub_DollarName '$func_cygpath_result')}
                        )
                      ]
                    )
                    (C {(func_convert_path_check)} {(Lit_Other ':')} {(Lit_Other ':')} 
                      {(DQ ($ VSub_DollarName '$func_to_host_path_tmp1'))} {(DQ ($ VSub_DollarName '$func_to_host_path_result'))}
                    )
                    (C {(func_convert_path_front_back_pathsep)} {(DQ (':*'))} {(DQ ('*:'))} 
                      {(Lit_Other ':')} {(DQ ($ VSub_Number '$1'))}
                    )
                  ]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: func_convert_path_nix_to_cygwin
      body: 
        (command.BraceGroup
          children: [
            (C {($ VSub_DollarName '$debug_cmd')})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:func_to_host_path_result)
                  op: Equal
                  rhs: {($ VSub_Number '$1')}
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: (C {(test)} {(-n)} {(DQ ($ VSub_Number '$1'))})
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (C {(func_stripname)} {(Lit_Other ':')} {(Lit_Other ':')} {(DQ ($ VSub_Number '$1'))})
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:func_to_host_path_tmp1)
                          op: Equal
                          rhs: {($ VSub_DollarName '$func_stripname_result')}
                        )
                      ]
                    )
                    (C {(func_convert_core_path_wine_to_w32)} 
                      {(DQ ($ VSub_DollarName '$func_to_host_path_tmp1'))}
                    )
                    (C {(func_cygpath)} {(-u)} {(-p)} 
                      {(DQ ($ VSub_DollarName '$func_convert_core_path_wine_to_w32_result'))}
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:func_to_host_path_result)
                          op: Equal
                          rhs: {($ VSub_DollarName '$func_cygpath_result')}
                        )
                      ]
                    )
                    (C {(func_convert_path_check)} {(Lit_Other ':')} {(Lit_Other ':')} 
                      {(DQ ($ VSub_DollarName '$func_to_host_path_tmp1'))} {(DQ ($ VSub_DollarName '$func_to_host_path_result'))}
                    )
                    (C {(func_convert_path_front_back_pathsep)} {(DQ (':*'))} {(DQ ('*:'))} 
                      {(Lit_Other ':')} {(DQ ($ VSub_Number '$1'))}
                    )
                  ]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: func_dll_def_p
      body: 
        (command.BraceGroup
          children: [
            (C {($ VSub_DollarName '$debug_cmd')})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:func_dll_def_p_tmp)
                  op: Equal
                  rhs: 
                    {
                      (command_sub
                        left_token: <Left_Backtick '`'>
                        command_list: 
                          (command.CommandList
                            children: [
                              (C {($ VSub_DollarName '$SED')} {(-n)} {(-e)} {(SQ <'s/^[\t ]*//'>)} {(-e)} 
                                {(SQ <'/^\\(;.*\\)*$/d'>)} {(-e)} {(SQ <'s/^\\(EXPORTS\\|LIBRARY\\)\\([\t ].*\\)*$/DEF/p'>)} {(-e)} {(q)} {(DQ ($ VSub_Number '$1'))}
                              )
                            ]
                          )
                      )
                    }
                )
              ]
            )
            (C {(test)} {(DEF)} {(Lit_Equals '=')} {(DQ ($ VSub_DollarName '$func_dll_def_p_tmp'))})
          ]
        )
    )
    (command.ShFunction
      name: func_mode_compile
      body: 
        (command.BraceGroup
          children: [
            (C {($ VSub_DollarName '$debug_cmd')})
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:base_compile) op:Equal rhs:(word.Empty))]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:srcfile)
                  op: Equal
                  rhs: {($ VSub_DollarName '$nonopt')}
                )
              ]
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:suppress_opt) op:Equal rhs:{(yes)})]
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:suppress_output) op:Equal rhs:(word.Empty))]
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:arg_mode) op:Equal rhs:{(normal)})]
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:libobj) op:Equal rhs:(word.Empty))]
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:later) op:Equal rhs:(word.Empty))]
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:pie_flag) op:Equal rhs:(word.Empty))]
            )
            (command.ForEach
              iter_name: arg
              do_arg_iter: T
              body: 
                (command.DoGroup
                  children: [
                    (command.Case
                      to_match: {($ VSub_DollarName '$arg_mode')}
                      arms: [
                        (case_arm
                          pat_list: [{(arg)}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:lastarg)
                                  op: Equal
                                  rhs: {($ VSub_DollarName '$arg')}
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:arg_mode)
                                  op: Equal
                                  rhs: {(normal)}
                                )
                              ]
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(target)}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:libobj)
                                  op: Equal
                                  rhs: {($ VSub_DollarName '$arg')}
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:arg_mode)
                                  op: Equal
                                  rhs: {(normal)}
                                )
                              ]
                            )
                            (command.ControlFlow
                              token: <ControlFlow_Continue continue>
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(normal)}]
                          action: [
                            (command.Case
                              to_match: {($ VSub_DollarName '$arg')}
                              arms: [
                                (case_arm
                                  pat_list: [{(-o)}]
                                  action: [
                                    (command.AndOr
                                      ops: [Op_DAmp]
                                      children: [
                                        (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$libobj'))})
                                        (C {(func_fatal_error)} 
                                          {(DQ ("you cannot specify '-o' more than once"))}
                                        )
                                      ]
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:arg_mode)
                                          op: Equal
                                          rhs: {(target)}
                                        )
                                      ]
                                    )
                                    (command.ControlFlow
                                      token: <ControlFlow_Continue continue>
                                    )
                                  ]
                                )
                                (case_arm
                                  pat_list: [{(-pie)} {(-fpie)} {(-fPIE)}]
                                  action: [
                                    (C {(func_append)} {(pie_flag)} 
                                      {(DQ (' ') ($ VSub_DollarName '$arg'))}
                                    )
                                    (command.ControlFlow
                                      token: <ControlFlow_Continue continue>
                                    )
                                  ]
                                )
                                (case_arm
                                  pat_list: [{(-shared)} {(-static)} {(-prefer-pic)} {(-prefer-non-pic)}]
                                  action: [
                                    (C {(func_append)} {(later)} {(DQ (' ') ($ VSub_DollarName '$arg'))})
                                    (command.ControlFlow
                                      token: <ControlFlow_Continue continue>
                                    )
                                  ]
                                )
                                (case_arm
                                  pat_list: [{(-no-suppress)}]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:suppress_opt)
                                          op: Equal
                                          rhs: {(no)}
                                        )
                                      ]
                                    )
                                    (command.ControlFlow
                                      token: <ControlFlow_Continue continue>
                                    )
                                  ]
                                )
                                (case_arm
                                  pat_list: [{(-Xcompiler)}]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:arg_mode)
                                          op: Equal
                                          rhs: {(arg)}
                                        )
                                      ]
                                    )
                                    (command.ControlFlow
                                      token: <ControlFlow_Continue continue>
                                    )
                                  ]
                                )
                                (case_arm
                                  pat_list: [{(-Wc) (Lit_Comma ',') (Lit_Star '*')}]
                                  action: [
                                    (C {(func_stripname)} {(SQ <'-Wc,'>)} {(SQ )} 
                                      {(DQ ($ VSub_DollarName '$arg'))}
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:args)
                                          op: Equal
                                          rhs: {($ VSub_DollarName '$func_stripname_result')}
                                        )
                                      ]
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:lastarg)
                                          op: Equal
                                          rhs: (word.Empty)
                                        )
                                      ]
                                    )
                                    (command.Sentence
                                      child: 
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:save_ifs)
                                              op: Equal
                                              rhs: {($ VSub_DollarName '$IFS')}
                                            )
                                          ]
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:IFS)
                                          op: Equal
                                          rhs: {(Lit_Comma ',')}
                                        )
                                      ]
                                    )
                                    (command.ForEach
                                      iter_name: arg
                                      iter_words: [{($ VSub_DollarName '$args')}]
                                      do_arg_iter: F
                                      body: 
                                        (command.DoGroup
                                          children: [
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:IFS)
                                                  op: Equal
                                                  rhs: {($ VSub_DollarName '$save_ifs')}
                                                )
                                              ]
                                            )
                                            (C {(func_append_quoted)} {(lastarg)} 
                                              {(DQ ($ VSub_DollarName '$arg'))}
                                            )
                                          ]
                                        )
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:IFS)
                                          op: Equal
                                          rhs: {($ VSub_DollarName '$save_ifs')}
                                        )
                                      ]
                                    )
                                    (C {(func_stripname)} {(SQ <' '>)} {(SQ )} 
                                      {(DQ ($ VSub_DollarName '$lastarg'))}
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:lastarg)
                                          op: Equal
                                          rhs: {($ VSub_DollarName '$func_stripname_result')}
                                        )
                                      ]
                                    )
                                    (C {(func_append)} {(base_compile)} 
                                      {(DQ (' ') ($ VSub_DollarName '$lastarg'))}
                                    )
                                    (command.ControlFlow
                                      token: <ControlFlow_Continue continue>
                                    )
                                  ]
                                )
                                (case_arm
                                  pat_list: [{(Lit_Star '*')}]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:lastarg)
                                          op: Equal
                                          rhs: {($ VSub_DollarName '$srcfile')}
                                        )
                                      ]
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:srcfile)
                                          op: Equal
                                          rhs: {($ VSub_DollarName '$arg')}
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                            )
                          ]
                        )
                      ]
                    )
                    (C {(func_append_quoted)} {(base_compile)} {(DQ ($ VSub_DollarName '$lastarg'))})
                  ]
                )
            )
            (command.Case
              to_match: {($ VSub_DollarName '$arg_mode')}
              arms: [
                (case_arm
                  pat_list: [{(arg)}]
                  action: [
                    (C {(func_fatal_error)} {(DQ ('you must specify an argument for -Xcompile'))})
                  ]
                )
                (case_arm
                  pat_list: [{(target)}]
                  action: [(C {(func_fatal_error)} {(DQ ("you must specify a target with '-o'"))})]
                )
                (case_arm
                  pat_list: [{(Lit_Star '*')}]
                  action: [
                    (command.AndOr
                      ops: [Op_DAmp]
                      children: [
                        (C {(test)} {(-z)} {(DQ ($ VSub_DollarName '$libobj'))})
                        (command.BraceGroup
                          children: [
                            (C {(func_basename)} {(DQ ($ VSub_DollarName '$srcfile'))})
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:libobj)
                                  op: Equal
                                  rhs: {($ VSub_DollarName '$func_basename_result')}
                                )
                              ]
                            )
                          ]
                        )
                      ]
                    )
                  ]
                )
              ]
            )
            (command.Case
              to_match: {($ VSub_DollarName '$libobj')}
              arms: [
                (case_arm
                  pat_list: [
                    {(Lit_Star '*') (.) (Lit_LBracket '[') (cCFSifmso) (Lit_RBracket ']')}
                    {(Lit_Star '*') (.ada)}
                    {(Lit_Star '*') (.adb)}
                    {(Lit_Star '*') (.ads)}
                    {(Lit_Star '*') (.asm)}
                    {(Lit_Star '*') (.c) (Lit_Other '+') (Lit_Other '+')}
                    {(Lit_Star '*') (.cc)}
                    {(Lit_Star '*') (.ii)}
                    {(Lit_Star '*') (.class)}
                    {(Lit_Star '*') (.cpp)}
                    {(Lit_Star '*') (.cxx)}
                    {(Lit_Star '*') (.) (Lit_LBracket '[') (fF) (Lit_RBracket ']') (Lit_LBracket '[') (09) 
                      (Lit_RBracket ']') (Lit_QMark '?')
                    }
                    {(Lit_Star '*') (.for)}
                    {(Lit_Star '*') (.java)}
                    {(Lit_Star '*') (.go)}
                    {(Lit_Star '*') (.obj)}
                    {(Lit_Star '*') (.sx)}
                    {(Lit_Star '*') (.cu)}
                    {(Lit_Star '*') (.cup)}
                  ]
                  action: [
                    (C {(func_xform)} {(DQ ($ VSub_DollarName '$libobj'))})
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:libobj)
                          op: Equal
                          rhs: {($ VSub_DollarName '$func_xform_result')}
                        )
                      ]
                    )
                  ]
                )
              ]
            )
            (command.Case
              to_match: {($ VSub_DollarName '$libobj')}
              arms: [
                (case_arm
                  pat_list: [{(Lit_Star '*') (.lo)}]
                  action: [
                    (command.Sentence
                      child: (C {(func_lo2o)} {(DQ ($ VSub_DollarName '$libobj'))})
                      terminator: <Op_Semi ';'>
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:obj)
                          op: Equal
                          rhs: {($ VSub_DollarName '$func_lo2o_result')}
                        )
                      ]
                    )
                  ]
                )
                (case_arm
                  pat_list: [{(Lit_Star '*')}]
                  action: [
                    (C {(func_fatal_error)} 
                      {
                        (DQ ("cannot determine name of library object from '") 
                          ($ VSub_DollarName '$libobj') ("'")
                        )
                      }
                    )
                  ]
                )
              ]
            )
            (C {(func_infer_tag)} {($ VSub_DollarName '$base_compile')})
            (command.ForEach
              iter_name: arg
              iter_words: [{($ VSub_DollarName '$later')}]
              do_arg_iter: F
              body: 
                (command.DoGroup
                  children: [
                    (command.Case
                      to_match: {($ VSub_DollarName '$arg')}
                      arms: [
                        (case_arm
                          pat_list: [{(-shared)}]
                          action: [
                            (command.AndOr
                              ops: [Op_DPipe]
                              children: [
                                (C {(test)} {(yes)} {(Lit_Equals '=')} 
                                  {(DQ ($ VSub_DollarName '$build_libtool_libs'))}
                                )
                                (C {(func_fatal_configuration)} {(DQ ('cannot build a shared library'))})
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:build_old_libs)
                                  op: Equal
                                  rhs: {(no)}
                                )
                              ]
                            )
                            (command.ControlFlow
                              token: <ControlFlow_Continue continue>
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(-static)}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:build_libtool_libs)
                                  op: Equal
                                  rhs: {(no)}
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:build_old_libs)
                                  op: Equal
                                  rhs: {(yes)}
                                )
                              ]
                            )
                            (command.ControlFlow
                              token: <ControlFlow_Continue continue>
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(-prefer-pic)}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:pic_mode)
                                  op: Equal
                                  rhs: {(yes)}
                                )
                              ]
                            )
                            (command.ControlFlow
                              token: <ControlFlow_Continue continue>
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(-prefer-non-pic)}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:pic_mode)
                                  op: Equal
                                  rhs: {(no)}
                                )
                              ]
                            )
                            (command.ControlFlow
                              token: <ControlFlow_Continue continue>
                            )
                          ]
                        )
                      ]
                    )
                  ]
                )
            )
            (C {(func_quote_for_eval)} {(DQ ($ VSub_DollarName '$libobj'))})
            (command.AndOr
              ops: [Op_DAmp Op_DAmp]
              children: [
                (C {(test)} {(DQ (X) ($ VSub_DollarName '$libobj'))} {(KW_Bang '!') (Lit_Equals '=')} 
                  {(DQ (X) ($ VSub_DollarName '$func_quote_for_eval_result'))}
                )
                (command.Pipeline
                  children: [
                    (C {($ VSub_DollarName '$ECHO')} {(DQ (X) ($ VSub_DollarName '$libobj'))})
                    (C {($ VSub_DollarName '$GREP')} 
                      {(SQ <'[]~#^*{};<>?"'>) (DQ ("'")) (SQ <'\t &()|`$[]'>)}
                    )
                  ]
                  negated: F
                )
                (C {(func_warning)} 
                  {
                    (DQ ("libobj name '") ($ VSub_DollarName '$libobj') 
                      ("' may not contain shell special characters.")
                    )
                  }
                )
              ]
            )
            (C {(func_dirname_and_basename)} {(DQ ($ VSub_DollarName '$obj'))} {(DQ (/))} {(DQ )})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:objname)
                  op: Equal
                  rhs: {($ VSub_DollarName '$func_basename_result')}
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:xdir)
                  op: Equal
                  rhs: {($ VSub_DollarName '$func_dirname_result')}
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:lobj)
                  op: Equal
                  rhs: 
                    {($ VSub_DollarName '$xdir') ($ VSub_DollarName '$objdir') (/) 
                      ($ VSub_DollarName '$objname')
                    }
                )
              ]
            )
            (command.AndOr
              ops: [Op_DAmp]
              children: [
                (C {(test)} {(-z)} {(DQ ($ VSub_DollarName '$base_compile'))})
                (C {(func_fatal_help)} {(DQ ('you must specify a compilation command'))})
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: 
                        (C {(test)} {(yes)} {(Lit_Equals '=')} 
                          {(DQ ($ VSub_DollarName '$build_old_libs'))}
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:removelist)
                          op: Equal
                          rhs: 
                            {
                              (DQ ($ VSub_DollarName '$obj') (' ') ($ VSub_DollarName '$lobj') (' ') 
                                ($ VSub_DollarName '$libobj') (' ') (${ VSub_Name libobj) (T)
                              )
                            }
                        )
                      ]
                    )
                  ]
                )
              ]
              else_action: [
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:removelist)
                      op: Equal
                      rhs: 
                        {
                          (DQ ($ VSub_DollarName '$lobj') (' ') ($ VSub_DollarName '$libobj') (' ') 
                            (${ VSub_Name libobj) (T)
                          )
                        }
                    )
                  ]
                )
              ]
            )
            (command.Case
              to_match: {($ VSub_DollarName '$host_os')}
              arms: [
                (case_arm
                  pat_list: [
                    {(cygwin) (Lit_Star '*')}
                    {(mingw) (Lit_Star '*')}
                    {(pw32) (Lit_Star '*')}
                    {(os2) (Lit_Star '*')}
                    {(cegcc) (Lit_Star '*')}
                  ]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:pic_mode)
                          op: Equal
                          rhs: {(default)}
                        )
                      ]
                    )
                  ]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: 
                        (command.AndOr
                          ops: [Op_DAmp]
                          children: [
                            (C {(test)} {(no)} {(Lit_Equals '=')} {(DQ ($ VSub_DollarName '$pic_mode'))})
                            (C {(test)} {(pass_all)} {(KW_Bang '!') (Lit_Equals '=')} 
                              {(DQ ($ VSub_DollarName '$deplibs_check_method'))}
                            )
                          ]
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:pic_mode)
                          op: Equal
                          rhs: {(default)}
                        )
                      ]
                    )
                  ]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: 
                        (C {(test)} {(no)} {(Lit_Equals '=')} {(DQ ($ VSub_DollarName '$compiler_c_o'))})
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:output_obj)
                          op: Equal
                          rhs: 
                            {
                              (command_sub
                                left_token: <Left_Backtick '`'>
                                command_list: 
                                  (command.CommandList
                                    children: [
                                      (command.Pipeline
                                        children: [
                                          (C {($ VSub_DollarName '$ECHO')} 
                                            {(DQ ($ VSub_DollarName '$srcfile'))}
                                          )
                                          (C {($ VSub_DollarName '$SED')} 
                                            {(SQ <'s%^.*/%%; s%\\.[^.]*$%%'>)}
                                          )
                                        ]
                                        negated: F
                                      )
                                    ]
                                  )
                              ) (.) ($ VSub_DollarName '$objext')
                            }
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:lockfile)
                          op: Equal
                          rhs: {($ VSub_DollarName '$output_obj') (.lock)}
                        )
                      ]
                    )
                  ]
                )
              ]
              else_action: [
                (command.ShAssignment
                  pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:output_obj) op:Equal rhs:(word.Empty))]
                )
                (command.ShAssignment
                  pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:need_locks) op:Equal rhs:{(no)})]
                )
                (command.ShAssignment
                  pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:lockfile) op:Equal rhs:(word.Empty))]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: 
                        (C {(test)} {(yes)} {(Lit_Equals '=')} {(DQ ($ VSub_DollarName '$need_locks'))})
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (command.WhileUntil
                      keyword: <KW_Until until>
                      cond: [
                        (command.Sentence
                          child: 
                            (command.AndOr
                              ops: [Op_DPipe]
                              children: [
                                (C {($ VSub_DollarName '$opt_dry_run')})
                                (command.Simple
                                  words: [
                                    {(ln)}
                                    {(DQ ($ VSub_DollarName '$progpath'))}
                                    {(DQ ($ VSub_DollarName '$lockfile'))}
                                  ]
                                  redirects: [
                                    (redir.Redir
                                      op: <Redir_Great '2>'>
                                      fd: 2
                                      arg_word: {(/dev/null)}
                                    )
                                  ]
                                )
                              ]
                            )
                          terminator: <Op_Semi ';'>
                        )
                      ]
                      body: 
                        (command.DoGroup
                          children: [
                            (C {(func_echo)} 
                              {
                                (DQ ('Waiting for ') ($ VSub_DollarName '$lockfile') (' to be removed'))
                              }
                            )
                            (C {(sleep)} {(2)})
                          ]
                        )
                    )
                  ]
                )
                (if_arm
                  cond: [
                    (command.Sentence
                      child: 
                        (C {(test)} {(warn)} {(Lit_Equals '=')} {(DQ ($ VSub_DollarName '$need_locks'))})
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: (C {(test)} {(-f)} {(DQ ($ VSub_DollarName '$lockfile'))})
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [
                            (C {($ VSub_DollarName '$ECHO')} 
                              {
                                (DQ ('*** ERROR, ') ($ VSub_DollarName '$lockfile') 
                                  (' exists and contains:\n') 
                                  (command_sub
                                    left_token: <Left_Backtick '`'>
                                    command_list: 
                                      (command.CommandList
                                        children: [
                                          (command.Simple
                                            words: [{(cat)} {($ VSub_DollarName '$lockfile')}]
                                            redirects: [
                                              (redir.Redir
                                                op: <Redir_Great '2>'>
                                                fd: 2
                                                arg_word: {(/dev/null)}
                                              )
                                            ]
                                          )
                                        ]
                                      )
                                  ) ('\n') ('\n') ('This indicates that another process is trying to use the same\n') 
                                  (
'temporary object file, and libtool could not work around it because\n'
                                  ) ("your compiler does not support '-c' and '-o' together.  If you\n") 
                                  (
'repeat this compilation, it may succeed, by chance, but you had better\n'
                                  ) ('avoid parallel builds (make -j) in this platform, or get a better\n') (compiler.)
                                )
                              }
                            )
                            (command.AndOr
                              ops: [Op_DPipe]
                              children: [
                                (C {($ VSub_DollarName '$opt_dry_run')})
                                (C {($ VSub_DollarName '$RM')} {($ VSub_DollarName '$removelist')})
                              ]
                            )
                            (command.ControlFlow
                              token: <ControlFlow_Exit exit>
                              arg_word: {($ VSub_DollarName '$EXIT_FAILURE')}
                            )
                          ]
                        )
                      ]
                    )
                    (C {(func_append)} {(removelist)} {(DQ (' ') ($ VSub_DollarName '$output_obj'))})
                    (command.Simple
                      words: [{($ VSub_DollarName '$ECHO')} {(DQ ($ VSub_DollarName '$srcfile'))}]
                      redirects: [
                        (redir.Redir
                          op: <Redir_Great '>'>
                          fd: 16777215
                          arg_word: {(DQ ($ VSub_DollarName '$lockfile'))}
                        )
                      ]
                    )
                  ]
                )
              ]
            )
            (command.AndOr
              ops: [Op_DPipe]
              children: [
                (C {($ VSub_DollarName '$opt_dry_run')})
                (C {($ VSub_DollarName '$RM')} {($ VSub_DollarName '$removelist')})
              ]
            )
            (C {(func_append)} {(removelist)} {(DQ (' ') ($ VSub_DollarName '$lockfile'))})
            (C {(trap)} {(SQ <'$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE'>)} {(1)} {(2)} {(15)})
            (C {(func_to_tool_file)} {(DQ ($ VSub_DollarName '$srcfile'))} 
              {(func_convert_file_msys_to_w32)}
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:srcfile)
                  op: Equal
                  rhs: {($ VSub_DollarName '$func_to_tool_file_result')}
                )
              ]
            )
            (C {(func_quote_for_eval)} {(DQ ($ VSub_DollarName '$srcfile'))})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:qsrcfile)
                  op: Equal
                  rhs: {($ VSub_DollarName '$func_quote_for_eval_result')}
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: 
                        (C {(test)} {(yes)} {(Lit_Equals '=')} 
                          {(DQ ($ VSub_DollarName '$build_libtool_libs'))}
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:fbsd_hideous_sh_bug)
                          op: Equal
                          rhs: {($ VSub_DollarName '$base_compile')}
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: 
                                (C {(test)} {(no)} {(KW_Bang '!') (Lit_Equals '=')} 
                                  {(DQ ($ VSub_DollarName '$pic_mode'))}
                                )
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:command)
                                  op: Equal
                                  rhs: 
                                    {
                                      (DQ ($ VSub_DollarName '$base_compile') (' ') 
                                        ($ VSub_DollarName '$qsrcfile') (' ') ($ VSub_DollarName '$pic_flag')
                                      )
                                    }
                                )
                              ]
                            )
                          ]
                        )
                      ]
                      else_action: [
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:command)
                              op: Equal
                              rhs: 
                                {
                                  (DQ ($ VSub_DollarName '$base_compile') (' ') 
                                    ($ VSub_DollarName '$qsrcfile')
                                  )
                                }
                            )
                          ]
                        )
                      ]
                    )
                    (C {(func_mkdir_p)} {(DQ ($ VSub_DollarName '$xdir') ($ VSub_DollarName '$objdir'))})
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: (C {(test)} {(-z)} {(DQ ($ VSub_DollarName '$output_obj'))})
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [
                            (C {(func_append)} {(command)} {(DQ (' -o ') ($ VSub_DollarName '$lobj'))})
                          ]
                        )
                      ]
                    )
                    (C {(func_show_eval_locale)} {(DQ ($ VSub_DollarName '$command'))} 
                      {(SQ <'test -n "$output_obj" && $RM $removelist; exit $EXIT_FAILURE'>)}
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: 
                                (command.AndOr
                                  ops: [Op_DAmp]
                                  children: [
                                    (C {(test)} {(warn)} {(Lit_Equals '=')} 
                                      {(DQ ($ VSub_DollarName '$need_locks'))}
                                    )
                                    (C {(test)} 
                                      {
                                        (DQ (X) 
                                          (command_sub
                                            left_token: <Left_Backtick '`'>
                                            command_list: 
                                              (command.CommandList
                                                children: [
                                                  (command.Simple
                                                    words: [{(cat)} {($ VSub_DollarName '$lockfile')}]
                                                    redirects: [
                                                      (redir.Redir
                                                        op: <Redir_Great '2>'>
                                                        fd: 2
                                                        arg_word: {(/dev/null)}
                                                      )
                                                    ]
                                                  )
                                                ]
                                              )
                                          )
                                        )
                                      } {(KW_Bang '!') (Lit_Equals '=')} {(DQ (X) ($ VSub_DollarName '$srcfile'))}
                                    )
                                  ]
                                )
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [
                            (C {($ VSub_DollarName '$ECHO')} 
                              {
                                (DQ ('*** ERROR, ') ($ VSub_DollarName '$lockfile') (' contains:\n') 
                                  (command_sub
                                    left_token: <Left_Backtick '`'>
                                    command_list: 
                                      (command.CommandList
                                        children: [
                                          (command.Simple
                                            words: [{(cat)} {($ VSub_DollarName '$lockfile')}]
                                            redirects: [
                                              (redir.Redir
                                                op: <Redir_Great '2>'>
                                                fd: 2
                                                arg_word: {(/dev/null)}
                                              )
                                            ]
                                          )
                                        ]
                                      )
                                  ) ('\n') ('\n') ('but it should contain:\n') ($ VSub_DollarName '$srcfile') ('\n') ('\n') 
                                  (
'This indicates that another process is trying to use the same\n'
                                  ) ('temporary object file, and libtool could not work around it because\n') 
                                  (
"your compiler does not support '-c' and '-o' together.  If you\n"
                                  ) ('repeat this compilation, it may succeed, by chance, but you had better\n') 
                                  (
'avoid parallel builds (make -j) in this platform, or get a better\n'
                                  ) (compiler.)
                                )
                              }
                            )
                            (command.AndOr
                              ops: [Op_DPipe]
                              children: [
                                (C {($ VSub_DollarName '$opt_dry_run')})
                                (C {($ VSub_DollarName '$RM')} {($ VSub_DollarName '$removelist')})
                              ]
                            )
                            (command.ControlFlow
                              token: <ControlFlow_Exit exit>
                              arg_word: {($ VSub_DollarName '$EXIT_FAILURE')}
                            )
                          ]
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: 
                                (command.AndOr
                                  ops: [Op_DAmp]
                                  children: [
                                    (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$output_obj'))})
                                    (C {(test)} {(DQ (X) ($ VSub_DollarName '$output_obj'))} 
                                      {(KW_Bang '!') (Lit_Equals '=')} {(DQ (X) ($ VSub_DollarName '$lobj'))}
                                    )
                                  ]
                                )
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [
                            (C {(func_show_eval)} {(SQ <'$MV "$output_obj" "$lobj"'>)} 
                              {(SQ <'error=$?; $opt_dry_run || $RM $removelist; exit $error'>)}
                            )
                          ]
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: 
                                (C {(test)} {(yes)} {(Lit_Equals '=')} 
                                  {(DQ ($ VSub_DollarName '$suppress_opt'))}
                                )
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:suppress_output)
                                  op: Equal
                                  rhs: {(SQ <' >/dev/null 2>&1'>)}
                                )
                              ]
                            )
                          ]
                        )
                      ]
                    )
                  ]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: 
                        (C {(test)} {(yes)} {(Lit_Equals '=')} 
                          {(DQ ($ VSub_DollarName '$build_old_libs'))}
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: 
                                (C {(test)} {(yes)} {(KW_Bang '!') (Lit_Equals '=')} 
                                  {(DQ ($ VSub_DollarName '$pic_mode'))}
                                )
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:command)
                                  op: Equal
                                  rhs: 
                                    {
                                      (DQ ($ VSub_DollarName '$base_compile') (' ') 
                                        ($ VSub_DollarName '$qsrcfile') ($ VSub_DollarName '$pie_flag')
                                      )
                                    }
                                )
                              ]
                            )
                          ]
                        )
                      ]
                      else_action: [
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:command)
                              op: Equal
                              rhs: 
                                {
                                  (DQ ($ VSub_DollarName '$base_compile') (' ') 
                                    ($ VSub_DollarName '$qsrcfile') (' ') ($ VSub_DollarName '$pic_flag')
                                  )
                                }
                            )
                          ]
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: 
                                (C {(test)} {(yes)} {(Lit_Equals '=')} 
                                  {(DQ ($ VSub_DollarName '$compiler_c_o'))}
                                )
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [
                            (C {(func_append)} {(command)} {(DQ (' -o ') ($ VSub_DollarName '$obj'))})
                          ]
                        )
                      ]
                    )
                    (C {(func_append)} {(command)} {(DQ ($ VSub_DollarName '$suppress_output'))})
                    (C {(func_show_eval_locale)} {(DQ ($ VSub_DollarName '$command'))} 
                      {(SQ <'$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE'>)}
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: 
                                (command.AndOr
                                  ops: [Op_DAmp]
                                  children: [
                                    (C {(test)} {(warn)} {(Lit_Equals '=')} 
                                      {(DQ ($ VSub_DollarName '$need_locks'))}
                                    )
                                    (C {(test)} 
                                      {
                                        (DQ (X) 
                                          (command_sub
                                            left_token: <Left_Backtick '`'>
                                            command_list: 
                                              (command.CommandList
                                                children: [
                                                  (command.Simple
                                                    words: [{(cat)} {($ VSub_DollarName '$lockfile')}]
                                                    redirects: [
                                                      (redir.Redir
                                                        op: <Redir_Great '2>'>
                                                        fd: 2
                                                        arg_word: {(/dev/null)}
                                                      )
                                                    ]
                                                  )
                                                ]
                                              )
                                          )
                                        )
                                      } {(KW_Bang '!') (Lit_Equals '=')} {(DQ (X) ($ VSub_DollarName '$srcfile'))}
                                    )
                                  ]
                                )
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [
                            (C {($ VSub_DollarName '$ECHO')} 
                              {
                                (DQ ('*** ERROR, ') ($ VSub_DollarName '$lockfile') (' contains:\n') 
                                  (command_sub
                                    left_token: <Left_Backtick '`'>
                                    command_list: 
                                      (command.CommandList
                                        children: [
                                          (command.Simple
                                            words: [{(cat)} {($ VSub_DollarName '$lockfile')}]
                                            redirects: [
                                              (redir.Redir
                                                op: <Redir_Great '2>'>
                                                fd: 2
                                                arg_word: {(/dev/null)}
                                              )
                                            ]
                                          )
                                        ]
                                      )
                                  ) ('\n') ('\n') ('but it should contain:\n') ($ VSub_DollarName '$srcfile') ('\n') ('\n') 
                                  (
'This indicates that another process is trying to use the same\n'
                                  ) ('temporary object file, and libtool could not work around it because\n') 
                                  (
"your compiler does not support '-c' and '-o' together.  If you\n"
                                  ) ('repeat this compilation, it may succeed, by chance, but you had better\n') 
                                  (
'avoid parallel builds (make -j) in this platform, or get a better\n'
                                  ) (compiler.)
                                )
                              }
                            )
                            (command.AndOr
                              ops: [Op_DPipe]
                              children: [
                                (C {($ VSub_DollarName '$opt_dry_run')})
                                (C {($ VSub_DollarName '$RM')} {($ VSub_DollarName '$removelist')})
                              ]
                            )
                            (command.ControlFlow
                              token: <ControlFlow_Exit exit>
                              arg_word: {($ VSub_DollarName '$EXIT_FAILURE')}
                            )
                          ]
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: 
                                (command.AndOr
                                  ops: [Op_DAmp]
                                  children: [
                                    (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$output_obj'))})
                                    (C {(test)} {(DQ (X) ($ VSub_DollarName '$output_obj'))} 
                                      {(KW_Bang '!') (Lit_Equals '=')} {(DQ (X) ($ VSub_DollarName '$obj'))}
                                    )
                                  ]
                                )
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [
                            (C {(func_show_eval)} {(SQ <'$MV "$output_obj" "$obj"'>)} 
                              {(SQ <'error=$?; $opt_dry_run || $RM $removelist; exit $error'>)}
                            )
                          ]
                        )
                      ]
                    )
                  ]
                )
              ]
            )
            (command.AndOr
              ops: [Op_DPipe]
              children: [
                (C {($ VSub_DollarName '$opt_dry_run')})
                (command.BraceGroup
                  children: [
                    (C {(func_write_libtool_object)} {(DQ ($ VSub_DollarName '$libobj'))} 
                      {(DQ ($ VSub_DollarName '$objdir') (/) ($ VSub_DollarName '$objname'))} {(DQ ($ VSub_DollarName '$objname'))}
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: 
                                (C {(test)} {(no)} {(KW_Bang '!') (Lit_Equals '=')} 
                                  {(DQ ($ VSub_DollarName '$need_locks'))}
                                )
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:removelist)
                                  op: Equal
                                  rhs: {($ VSub_DollarName '$lockfile')}
                                )
                              ]
                            )
                            (C {($ VSub_DollarName '$RM')} {(DQ ($ VSub_DollarName '$lockfile'))})
                          ]
                        )
                      ]
                    )
                  ]
                )
              ]
            )
            (command.ControlFlow
              token: <ControlFlow_Exit exit>
              arg_word: {($ VSub_DollarName '$EXIT_SUCCESS')}
            )
          ]
        )
    )
    (command.AndOr
      ops: [Op_DPipe]
      children: [
        (C {($ VSub_DollarName '$opt_help')})
        (command.BraceGroup
          children: [
            (command.AndOr
              ops: [Op_DAmp]
              children: [
                (C {(test)} {(compile)} {(Lit_Equals '=')} {(DQ ($ VSub_DollarName '$opt_mode'))})
                (C {(func_mode_compile)} 
                  {
                    (braced_var_sub
                      token: <VSub_Number 1>
                      suffix_op: (suffix_op.Unary op_id:VTest_Plus arg_word:{(DQ ($ VSub_At '$@'))})
                    )
                  }
                )
              ]
            )
          ]
        )
      ]
    )
    (command.ShFunction
      name: func_mode_help
      body: 
        (command.BraceGroup
          children: [
            (command.Case
              to_match: {($ VSub_DollarName '$opt_mode')}
              arms: [
                (case_arm pat_list:[{(DQ )}] action:[(C {(func_help)})])
                (case_arm
                  pat_list: [{(clean)}]
                  action: [
                    (C {($ VSub_DollarName '$ECHO')} 
                      {
                        (DQ ('Usage: ') ($ VSub_DollarName '$progname') 
                          (' [OPTION]... --mode=clean RM [RM-OPTION]... FILE...\n') ('\n') ('Remove files from the build directory.\n') ('\n') 
                          (
'RM is the name of the program to use to delete files associated with each FILE\n'
                          ) ("(typically '/bin/rm').  RM-OPTIONS are options (such as '-f') to be passed\n") ('to RM.\n') ('\n') 
                          (
'If FILE is a libtool library, object or program, all the files associated\n'
                          ) ('with it are deleted. Otherwise, only FILE itself is deleted using RM.')
                        )
                      }
                    )
                  ]
                )
                (case_arm
                  pat_list: [{(compile)}]
                  action: [
                    (C {($ VSub_DollarName '$ECHO')} 
                      {
                        (DQ ('Usage: ') ($ VSub_DollarName '$progname') 
                          (' [OPTION]... --mode=compile COMPILE-COMMAND... SOURCEFILE\n') ('\n') ('Compile a source file into a libtool library object.\n') ('\n') 
                          ('This mode accepts the following additional options:\n') ('\n') ('  -o OUTPUT-FILE    set the output file name to OUTPUT-FILE\n') 
                          (
'  -no-suppress      do not suppress compiler output for multiple passes\n'
                          ) ('  -prefer-pic       try to build PIC objects only\n') 
                          ('  -prefer-non-pic   try to build non-PIC objects only\n') ("  -shared           do not build a '.o' file suitable for static linking\n") 
                          (
"  -static           only build a '.o' file suitable for static linking\n"
                          ) ('  -Wc,FLAG          pass FLAG directly to the compiler\n') ('\n') 
                          (
"COMPILE-COMMAND is a command to be used in creating a 'standard' object file\n"
                          ) ('from the given SOURCEFILE.\n') ('\n') 
                          (
'The output file name is determined by removing the directory component from\n'
                          ) ("SOURCEFILE, then substituting the C source code suffix '.c' with the\n") 
                          ("library object suffix, '.lo'.")
                        )
                      }
                    )
                  ]
                )
                (case_arm
                  pat_list: [{(execute)}]
                  action: [
                    (C {($ VSub_DollarName '$ECHO')} 
                      {
                        (DQ ('Usage: ') ($ VSub_DollarName '$progname') 
                          (' [OPTION]... --mode=execute COMMAND [ARGS]...\n') ('\n') ('Automatically set library path, then run a program.\n') ('\n') 
                          ('This mode accepts the following additional options:\n') ('\n') ('  -dlopen FILE      add the directory containing FILE to the library path\n') ('\n') 
                          (
"This mode sets the library path environment variable according to '-dlopen'\n"
                          ) ('flags.\n') ('\n') ('If any of the ARGS are libtool executable wrappers, then they are translated\n') 
                          (
'into their corresponding uninstalled binary, and any of their required library\n'
                          ) ('directories are added to the library path.\n') ('\n') 
                          ('Then, COMMAND is executed, with ARGS as arguments.')
                        )
                      }
                    )
                  ]
                )
                (case_arm
                  pat_list: [{(finish)}]
                  action: [
                    (C {($ VSub_DollarName '$ECHO')} 
                      {
                        (DQ ('Usage: ') ($ VSub_DollarName '$progname') 
                          (' [OPTION]... --mode=finish [LIBDIR]...\n') ('\n') ('Complete the installation of libtool libraries.\n') ('\n') 
                          ('Each LIBDIR is a directory that contains libtool libraries.\n') ('\n') ('The commands that this mode executes may require superuser privileges.  Use\n') 
                          ("the '--dry-run' option if you just want to see what would be executed.")
                        )
                      }
                    )
                  ]
                )
                (case_arm
                  pat_list: [{(install)}]
                  action: [
                    (C {($ VSub_DollarName '$ECHO')} 
                      {
                        (DQ ('Usage: ') ($ VSub_DollarName '$progname') 
                          (' [OPTION]... --mode=install INSTALL-COMMAND...\n') ('\n') ('Install executables or libraries.\n') ('\n') 
                          (
'INSTALL-COMMAND is the installation command.  The first component should be\n'
                          ) ("either the 'install' or 'cp' program.\n") ('\n') 
                          ('The following components of INSTALL-COMMAND are treated specially:\n') ('\n') ('  -inst-prefix-dir PREFIX-DIR  Use PREFIX-DIR as a staging area for installation\n') ('\n') 
                          (
'The rest of the components are interpreted as arguments to that command (only\n'
                          ) ('BSD-compatible install options are recognized).')
                        )
                      }
                    )
                  ]
                )
                (case_arm
                  pat_list: [{(link)}]
                  action: [
                    (C {($ VSub_DollarName '$ECHO')} 
                      {
                        (DQ ('Usage: ') ($ VSub_DollarName '$progname') 
                          (' [OPTION]... --mode=link LINK-COMMAND...\n') ('\n') ('Link object files or libraries together to form another library, or to\n') 
                          ('create an executable program.\n') ('\n') ('LINK-COMMAND is a command using the C compiler that you would use to create\n') 
                          ('a program from several object files.\n') ('\n') ('The following components of LINK-COMMAND are treated specially:\n') ('\n') 
                          ('  -all-static       do not do any dynamic linking at all\n') ('  -avoid-version    do not add a version suffix if possible\n') 
                          (
'  -bindir BINDIR    specify path to binaries directory (for systems where\n'
                          ) ('                    libraries must be found in the PATH setting at runtime)\n') 
                          (
"  -dlopen FILE      '-dlpreopen' FILE if it cannot be dlopened at runtime\n"
                          ) ('  -dlpreopen FILE   link in FILE and add its symbols to lt_preloaded_symbols\n') 
                          (
'  -export-dynamic   allow symbols from OUTPUT-FILE to be resolved with dlsym(3)\n'
                          ) ('  -export-symbols SYMFILE\n') 
                          ('                    try to export only the symbols listed in SYMFILE\n') ('  -export-symbols-regex REGEX\n') 
                          ('                    try to export only the symbols matching REGEX\n') ('  -LLIBDIR          search LIBDIR for required installed libraries\n') 
                          (
'  -lNAME            OUTPUT-FILE requires the installed library libNAME\n'
                          ) ('  -module           build a library that can dlopened\n') 
                          ('  -no-fast-install  disable the fast-install mode\n') ('  -no-install       link a not-installable executable\n') 
                          (
'  -no-undefined     declare that a library does not refer to external symbols\n'
                          ) ('  -o OUTPUT-FILE    create OUTPUT-FILE from the specified objects\n') 
                          (
'  -objectlist FILE  use a list of object files found in FILE to specify objects\n'
                          ) ('  -os2dllname NAME  force a short DLL name on OS/2 (no effect on other OSes)\n') 
                          ('  -precious-files-regex REGEX\n') ("                    don't remove output files matching REGEX\n") 
                          ('  -release RELEASE  specify package release information\n') ('  -rpath LIBDIR     the created library will eventually be installed in LIBDIR\n') 
                          (
'  -R[ ]LIBDIR       add LIBDIR to the runtime path of programs and libraries\n'
                          ) ('  -shared           only do dynamic linking of libtool libraries\n') 
                          (
'  -shrext SUFFIX    override the standard shared library file extension\n'
                          ) ('  -static           do not do any dynamic linking of uninstalled libtool libraries\n') 
                          ('  -static-libtool-libs\n') ('                    do not do any dynamic linking of libtool libraries\n') 
                          ('  -version-info CURRENT[:REVISION[:AGE]]\n') ('                    specify library version info [each variable defaults to 0]\n') 
                          (
'  -weak LIBNAME     declare that the target provides the LIBNAME interface\n'
                          ) ('  -Wc,FLAG\n') ('  -Xcompiler FLAG   pass linker-specific FLAG directly to the compiler\n') 
                          ('  -Wl,FLAG\n') ('  -Xlinker FLAG     pass linker-specific FLAG directly to the linker\n') 
                          (
'  -XCClinker FLAG   pass link-specific FLAG to the compiler driver (CC)\n'
                          ) ('\n') ("All other options (arguments beginning with '-') are ignored.\n") ('\n') 
                          (
"Every other argument is treated as a filename.  Files ending in '.la' are\n"
                          ) ('treated as uninstalled libtool libraries, other files are standard or library\n') 
                          ('object files.\n') ('\n') ("If the OUTPUT-FILE ends in '.la', then a libtool library is created,\n") 
                          ("only library objects ('.lo' files) may be specified, and '-rpath' is\n") ('required, except when creating a convenience library.\n') ('\n') 
                          (
"If OUTPUT-FILE ends in '.a' or '.lib', then a standard library is created\n"
                          ) ("using 'ar' and 'ranlib', or on Windows using 'lib'.\n") ('\n') ("If OUTPUT-FILE ends in '.lo' or '.") 
                          ($ VSub_DollarName '$objext') ("', then a reloadable object file\n") ('is created, otherwise an executable program is created.')
                        )
                      }
                    )
                  ]
                )
                (case_arm
                  pat_list: [{(uninstall)}]
                  action: [
                    (C {($ VSub_DollarName '$ECHO')} 
                      {
                        (DQ ('Usage: ') ($ VSub_DollarName '$progname') 
                          (' [OPTION]... --mode=uninstall RM [RM-OPTION]... FILE...\n') ('\n') ('Remove libraries from an installation directory.\n') ('\n') 
                          (
'RM is the name of the program to use to delete files associated with each FILE\n'
                          ) ("(typically '/bin/rm').  RM-OPTIONS are options (such as '-f') to be passed\n") ('to RM.\n') ('\n') 
                          (
'If FILE is a libtool library, all the files associated with it are deleted.\n'
                          ) ('Otherwise, only FILE itself is deleted using RM.')
                        )
                      }
                    )
                  ]
                )
                (case_arm
                  pat_list: [{(Lit_Star '*')}]
                  action: [
                    (C {(func_fatal_help)} 
                      {(DQ ("invalid operation mode '") ($ VSub_DollarName '$opt_mode') ("'"))}
                    )
                  ]
                )
              ]
            )
            (C {(echo)})
            (C {($ VSub_DollarName '$ECHO')} 
              {
                (DQ ("Try '") ($ VSub_DollarName '$progname') 
                  (" --help' for more information about other modes.")
                )
              }
            )
          ]
        )
    )
    (command.If
      arms: [
        (if_arm
          cond: [
            (command.Sentence
              child: (C {($ VSub_DollarName '$opt_help')})
              terminator: <Op_Semi ';'>
            )
          ]
          action: [
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: 
                        (C {(test)} {(Lit_Other ':')} {(Lit_Equals '=')} 
                          {(DQ ($ VSub_DollarName '$opt_help'))}
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [(C {(func_mode_help)})]
                )
              ]
              else_action: [
                (command.Pipeline
                  children: [
                    (command.BraceGroup
                      children: [
                        (C {(func_help)} {(noexit)})
                        (command.ForEach
                          iter_name: opt_mode
                          iter_words: [
                            {(compile)}
                            {(link)}
                            {(execute)}
                            {(install)}
                            {(finish)}
                            {(uninstall)}
                            {(clean)}
                          ]
                          do_arg_iter: F
                          body: (command.DoGroup children:[(C {(func_mode_help)})])
                        )
                      ]
                    )
                    (C {($ VSub_DollarName '$SED')} {(-n)} {(SQ <'1p; 2,$s/^Usage:/  or: /p'>)})
                  ]
                  negated: F
                )
                (command.Pipeline
                  children: [
                    (command.BraceGroup
                      children: [
                        (C {(func_help)} {(noexit)})
                        (command.ForEach
                          iter_name: opt_mode
                          iter_words: [
                            {(compile)}
                            {(link)}
                            {(execute)}
                            {(install)}
                            {(finish)}
                            {(uninstall)}
                            {(clean)}
                          ]
                          do_arg_iter: F
                          body: (command.DoGroup children:[(C {(echo)}) (C {(func_mode_help)})])
                        )
                      ]
                    )
                    (C {($ VSub_DollarName '$SED')} 
                      {
                        (SQ <'1d\n'> <'      /^When reporting/,/^Report/{\n'> <'\tH\n'> <'\td\n'> 
                          <'      }\n'> <'      $x\n'> <'      /information about other modes/d\n'> <'      /more detailed .*MODE/d\n'> 
                          <'      s/^Usage:.*--mode=\\([^ ]*\\) .*/Description of \\1 mode:/'>
                        )
                      }
                    )
                  ]
                  negated: F
                )
              ]
            )
            (command.ControlFlow
              token: <ControlFlow_Exit exit>
              arg_word: {($ VSub_QMark '$?')}
            )
          ]
        )
      ]
    )
    (command.ShFunction
      name: func_mode_execute
      body: 
        (command.BraceGroup
          children: [
            (C {($ VSub_DollarName '$debug_cmd')})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:cmd)
                  op: Equal
                  rhs: {($ VSub_DollarName '$nonopt')}
                )
              ]
            )
            (command.AndOr
              ops: [Op_DAmp]
              children: [
                (C {(test)} {(-z)} {(DQ ($ VSub_DollarName '$cmd'))})
                (C {(func_fatal_help)} {(DQ ('you must specify a COMMAND'))})
              ]
            )
            (command.ForEach
              iter_name: file
              iter_words: [{($ VSub_DollarName '$opt_dlopen')}]
              do_arg_iter: F
              body: 
                (command.DoGroup
                  children: [
                    (command.AndOr
                      ops: [Op_DPipe]
                      children: [
                        (C {(test)} {(-f)} {(DQ ($ VSub_DollarName '$file'))})
                        (C {(func_fatal_help)} 
                          {(DQ ("'") ($ VSub_DollarName '$file') ("' is not a file"))}
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:dir) op:Equal rhs:(word.Empty))]
                    )
                    (command.Case
                      to_match: {($ VSub_DollarName '$file')}
                      arms: [
                        (case_arm
                          pat_list: [{(Lit_Star '*') (.la)}]
                          action: [
                            (C {(func_resolve_sysroot)} {(DQ ($ VSub_DollarName '$file'))})
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:file)
                                  op: Equal
                                  rhs: {($ VSub_DollarName '$func_resolve_sysroot_result')}
                                )
                              ]
                            )
                            (command.AndOr
                              ops: [Op_DPipe]
                              children: [
                                (C {(func_lalib_unsafe_p)} {(DQ ($ VSub_DollarName '$file'))})
                                (C {(func_fatal_help)} 
                                  {
                                    (DQ ("'") ($ VSub_DollarName '$lib') 
                                      ("' is not a valid libtool archive")
                                    )
                                  }
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:dlname) op:Equal rhs:(word.Empty))]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:library_names)
                                  op: Equal
                                  rhs: (word.Empty)
                                )
                              ]
                            )
                            (C {(func_source)} {(DQ ($ VSub_DollarName '$file'))})
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: (C {(test)} {(-z)} {(DQ ($ VSub_DollarName '$dlname'))})
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (command.AndOr
                                      ops: [Op_DAmp]
                                      children: [
                                        (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$library_names'))})
                                        (C {(func_warning)} 
                                          {
                                            (DQ ("'") ($ VSub_DollarName '$file') 
                                              ("' was not linked with '-export-dynamic'")
                                            )
                                          }
                                        )
                                      ]
                                    )
                                    (command.ControlFlow
                                      token: <ControlFlow_Continue continue>
                                    )
                                  ]
                                )
                              ]
                            )
                            (C {(func_dirname)} {(DQ ($ VSub_DollarName '$file'))} {(DQ )} {(DQ (.))})
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:dir)
                                  op: Equal
                                  rhs: {($ VSub_DollarName '$func_dirname_result')}
                                )
                              ]
                            )
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (C {(test)} {(-f)} 
                                          {
                                            (DQ ($ VSub_DollarName '$dir') (/) 
                                              ($ VSub_DollarName '$objdir') (/) ($ VSub_DollarName '$dlname')
                                            )
                                          }
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (C {(func_append)} {(dir)} {(DQ (/) ($ VSub_DollarName '$objdir'))})
                                  ]
                                )
                              ]
                              else_action: [
                                (command.If
                                  arms: [
                                    (if_arm
                                      cond: [
                                        (command.Sentence
                                          child: 
                                            (C {(test)} {(KW_Bang '!')} {(-f)} 
                                              {
                                                (DQ ($ VSub_DollarName '$dir') (/) 
                                                  ($ VSub_DollarName '$dlname')
                                                )
                                              }
                                            )
                                          terminator: <Op_Semi ';'>
                                        )
                                      ]
                                      action: [
                                        (C {(func_fatal_error)} 
                                          {
                                            (DQ ("cannot find '") ($ VSub_DollarName '$dlname') 
                                              ("' in '") ($ VSub_DollarName '$dir') ("' or '") ($ VSub_DollarName '$dir') (/) ($ VSub_DollarName '$objdir') ("'")
                                            )
                                          }
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(Lit_Star '*') (.lo)}]
                          action: [
                            (C {(func_dirname)} {(DQ ($ VSub_DollarName '$file'))} {(DQ )} {(DQ (.))})
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:dir)
                                  op: Equal
                                  rhs: {($ VSub_DollarName '$func_dirname_result')}
                                )
                              ]
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(Lit_Star '*')}]
                          action: [
                            (C {(func_warning)} 
                              {(DQ ("'-dlopen' is ignored for non-libtool libraries and objects"))}
                            )
                            (command.ControlFlow
                              token: <ControlFlow_Continue continue>
                            )
                          ]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:absdir)
                          op: Equal
                          rhs: 
                            {
                              (command_sub
                                left_token: <Left_Backtick '`'>
                                command_list: 
                                  (command.CommandList
                                    children: [
                                      (command.AndOr
                                        ops: [Op_DAmp]
                                        children: [
                                          (C {(cd)} {(DQ ($ VSub_DollarName '$dir'))})
                                          (C {(pwd)})
                                        ]
                                      )
                                    ]
                                  )
                              )
                            }
                        )
                      ]
                    )
                    (command.AndOr
                      ops: [Op_DAmp]
                      children: [
                        (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$absdir'))})
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:dir)
                              op: Equal
                              rhs: {($ VSub_DollarName '$absdir')}
                            )
                          ]
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: 
                                (C {(eval)} 
                                  {
                                    (DQ ('test -z ') 
                                      (word_part.EscapedLiteral
                                        token: <Lit_EscapedChar '\\"'>
                                      ) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) ($ VSub_DollarName '$shlibpath_var') 
                                      (word_part.EscapedLiteral
                                        token: <Lit_EscapedChar '\\"'>
                                      )
                                    )
                                  }
                                )
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [
                            (C {(eval)} 
                              {
                                (DQ ($ VSub_DollarName '$shlibpath_var') ('=') 
                                  (word_part.EscapedLiteral
                                    token: <Lit_EscapedChar '\\"'>
                                  ) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) (dir) 
                                  (word_part.EscapedLiteral
                                    token: <Lit_EscapedChar '\\"'>
                                  )
                                )
                              }
                            )
                          ]
                        )
                      ]
                      else_action: [
                        (C {(eval)} 
                          {
                            (DQ ($ VSub_DollarName '$shlibpath_var') ('=') 
                              (word_part.EscapedLiteral
                                token: <Lit_EscapedChar '\\"'>
                              ) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) ('dir:') 
                              (word_part.EscapedLiteral
                                token: <Lit_EscapedChar '\\$'>
                              ) ($ VSub_DollarName '$shlibpath_var') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>)
                            )
                          }
                        )
                      ]
                    )
                  ]
                )
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:libtool_execute_magic)
                  op: Equal
                  rhs: {($ VSub_DollarName '$magic')}
                )
              ]
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:args) op:Equal rhs:(word.Empty))]
            )
            (command.ForEach
              iter_name: file
              do_arg_iter: T
              body: 
                (command.DoGroup
                  children: [
                    (command.Case
                      to_match: {($ VSub_DollarName '$file')}
                      arms: [
                        (case_arm
                          pat_list: [{(-) (Lit_Star '*')} {(Lit_Star '*') (.la)} {(Lit_Star '*') (.lo)}]
                        )
                        (case_arm
                          pat_list: [{(Lit_Star '*')}]
                          action: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (C {(func_ltwrapper_script_p)} 
                                          {(DQ ($ VSub_DollarName '$file'))}
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (C {(func_source)} {(DQ ($ VSub_DollarName '$file'))})
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:file)
                                          op: Equal
                                          rhs: 
                                            {($ VSub_DollarName '$progdir') (/) 
                                              ($ VSub_DollarName '$program')
                                            }
                                        )
                                      ]
                                    )
                                  ]
                                )
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (C {(func_ltwrapper_executable_p)} 
                                          {(DQ ($ VSub_DollarName '$file'))}
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (C {(func_ltwrapper_scriptname)} {(DQ ($ VSub_DollarName '$file'))})
                                    (C {(func_source)} 
                                      {(DQ ($ VSub_DollarName '$func_ltwrapper_scriptname_result'))}
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:file)
                                          op: Equal
                                          rhs: 
                                            {($ VSub_DollarName '$progdir') (/) 
                                              ($ VSub_DollarName '$program')
                                            }
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                            )
                          ]
                        )
                      ]
                    )
                    (C {(func_append_quoted)} {(args)} {(DQ ($ VSub_DollarName '$file'))})
                  ]
                )
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: (C {($ VSub_DollarName '$opt_dry_run')})
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$shlibpath_var'))})
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [
                            (C {(eval)} 
                              {
                                (DQ (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) ('ECHO ') 
                                  (word_part.EscapedLiteral
                                    token: <Lit_EscapedChar '\\"'>
                                  ) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) ('shlibpath_var=') 
                                  (word_part.EscapedLiteral
                                    token: <Lit_EscapedChar '\\$'>
                                  ) ($ VSub_DollarName '$shlibpath_var') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>)
                                )
                              }
                            )
                            (C {(echo)} {(DQ ('export ') ($ VSub_DollarName '$shlibpath_var'))})
                          ]
                        )
                      ]
                    )
                    (C {($ VSub_DollarName '$ECHO')} 
                      {(DQ ($ VSub_DollarName '$cmd') ($ VSub_DollarName '$args'))}
                    )
                    (command.ControlFlow
                      token: <ControlFlow_Exit exit>
                      arg_word: {($ VSub_DollarName '$EXIT_SUCCESS')}
                    )
                  ]
                )
              ]
              else_action: [
                (command.If
                  arms: [
                    (if_arm
                      cond: [
                        (command.Sentence
                          child: (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$shlibpath_var'))})
                          terminator: <Op_Semi ';'>
                        )
                      ]
                      action: [(C {(eval)} {(DQ ('export ') ($ VSub_DollarName '$shlibpath_var'))})]
                    )
                  ]
                )
                (command.ForEach
                  iter_name: lt_var
                  iter_words: [{(LANG)} {(LANGUAGE)} {(LC_ALL)} {(LC_CTYPE)} {(LC_COLLATE)} {(LC_MESSAGES)}]
                  do_arg_iter: F
                  body: 
                    (command.DoGroup
                      children: [
                        (C {(eval)} 
                          {
                            (DQ ('if test ') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) 
                              (word_part.EscapedLiteral
                                token: <Lit_EscapedChar '\\$'>
                              ) ('{save_') ($ VSub_DollarName '$lt_var') ('+set}') 
                              (word_part.EscapedLiteral
                                token: <Lit_EscapedChar '\\"'>
                              ) (' = set; then\n') ('                ') ($ VSub_DollarName '$lt_var') ('=') 
                              (word_part.EscapedLiteral
                                token: <Lit_EscapedChar '\\$'>
                              ) (save_) ($ VSub_DollarName '$lt_var') ('; export ') ($ VSub_DollarName '$lt_var') ('\n') 
                              ('\t      else\n') ('\t\t') ($ VSub_DollarName '$lt_unset') (' ') ($ VSub_DollarName '$lt_var') ('\n') ('\t      fi')
                            )
                          }
                        )
                      ]
                    )
                )
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:exec_cmd)
                      op: Equal
                      rhs: 
                        {(word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) (cmd) 
                          ($ VSub_DollarName '$args')
                        }
                    )
                  ]
                )
              ]
            )
          ]
        )
    )
    (command.AndOr
      ops: [Op_DAmp]
      children: [
        (C {(test)} {(execute)} {(Lit_Equals '=')} {(DQ ($ VSub_DollarName '$opt_mode'))})
        (C {(func_mode_execute)} 
          {
            (braced_var_sub
              token: <VSub_Number 1>
              suffix_op: (suffix_op.Unary op_id:VTest_Plus arg_word:{(DQ ($ VSub_At '$@'))})
            )
          }
        )
      ]
    )
    (command.ShFunction
      name: func_mode_finish
      body: 
        (command.BraceGroup
          children: [
            (C {($ VSub_DollarName '$debug_cmd')})
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:libs) op:Equal rhs:(word.Empty))]
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:libdirs) op:Equal rhs:(word.Empty))]
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:admincmds) op:Equal rhs:(word.Empty))]
            )
            (command.ForEach
              iter_name: opt
              iter_words: [
                {(DQ ($ VSub_DollarName '$nonopt'))}
                {
                  (braced_var_sub
                    token: <VSub_Number 1>
                    suffix_op: (suffix_op.Unary op_id:VTest_Plus arg_word:{(DQ ($ VSub_At '$@'))})
                  )
                }
              ]
              do_arg_iter: F
              body: 
                (command.DoGroup
                  children: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: (C {(test)} {(-d)} {(DQ ($ VSub_DollarName '$opt'))})
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [
                            (C {(func_append)} {(libdirs)} {(DQ (' ') ($ VSub_DollarName '$opt'))})
                          ]
                        )
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: (C {(test)} {(-f)} {(DQ ($ VSub_DollarName '$opt'))})
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (C {(func_lalib_unsafe_p)} {(DQ ($ VSub_DollarName '$opt'))})
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (C {(func_append)} {(libs)} {(DQ (' ') ($ VSub_DollarName '$opt'))})
                                  ]
                                )
                              ]
                              else_action: [
                                (C {(func_warning)} 
                                  {
                                    (DQ ("'") ($ VSub_DollarName '$opt') 
                                      ("' is not a valid libtool archive")
                                    )
                                  }
                                )
                              ]
                            )
                          ]
                        )
                      ]
                      else_action: [
                        (C {(func_fatal_error)} 
                          {(DQ ("invalid argument '") ($ VSub_DollarName '$opt') ("'"))}
                        )
                      ]
                    )
                  ]
                )
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$libs'))})
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$lt_sysroot'))})
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:sysroot_regex)
                                  op: Equal
                                  rhs: 
                                    {
                                      (command_sub
                                        left_token: <Left_Backtick '`'>
                                        command_list: 
                                          (command.CommandList
                                            children: [
                                              (command.Pipeline
                                                children: [
                                                  (C {($ VSub_DollarName '$ECHO')} 
                                                    {(DQ ($ VSub_DollarName '$lt_sysroot'))}
                                                  )
                                                  (C {($ VSub_DollarName '$SED')} 
                                                    {
                                                      (DQ 
                                                        ($ VSub_DollarName '$sed_make_literal_regex')
                                                      )
                                                    }
                                                  )
                                                ]
                                                negated: F
                                              )
                                            ]
                                          )
                                      )
                                    }
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:sysroot_cmd)
                                  op: Equal
                                  rhs: 
                                    {
                                      (DQ (s/) (Lit_Other '\\') ("([ ']") (Lit_Other '\\') (')') 
                                        ($ VSub_DollarName '$sysroot_regex') (/) (Lit_Other '\\') ('1/g;')
                                      )
                                    }
                                )
                              ]
                            )
                          ]
                        )
                      ]
                      else_action: [
                        (command.ShAssignment
                          pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:sysroot_cmd) op:Equal rhs:(word.Empty))]
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: (C {($ VSub_DollarName '$opt_dry_run')})
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [
                            (command.ForEach
                              iter_name: lib
                              iter_words: [{($ VSub_DollarName '$libs')}]
                              do_arg_iter: F
                              body: 
                                (command.DoGroup
                                  children: [
                                    (C {(echo)} 
                                      {
                                        (DQ ('removing references to ') 
                                          ($ VSub_DollarName '$lt_sysroot') (" and '=' prefixes from ") ($ VSub_DollarName '$lib')
                                        )
                                      }
                                    )
                                  ]
                                )
                            )
                          ]
                        )
                      ]
                      else_action: [
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:tmpdir)
                              op: Equal
                              rhs: 
                                {
                                  (command_sub
                                    left_token: <Left_Backtick '`'>
                                    command_list: 
                                      (command.CommandList
                                        children: [(C {(func_mktempdir)})]
                                      )
                                  )
                                }
                            )
                          ]
                        )
                        (command.ForEach
                          iter_name: lib
                          iter_words: [{($ VSub_DollarName '$libs')}]
                          do_arg_iter: F
                          body: 
                            (command.DoGroup
                              children: [
                                (command.Simple
                                  words: [
                                    {($ VSub_DollarName '$SED')}
                                    {(-e)}
                                    {
                                      (DQ ($ VSub_DollarName '$sysroot_cmd') (' s/') (Lit_Other '\\') 
                                        ("([ ']-[LR]") (Lit_Other '\\') (')=/') (Lit_Other '\\') ('1/g; s/') (Lit_Other '\\') ("([ ']") (Lit_Other '\\') (')=/') 
                                        (Lit_Other '\\') (1/g)
                                      )
                                    }
                                    {($ VSub_DollarName '$lib')}
                                  ]
                                  redirects: [
                                    (redir.Redir
                                      op: <Redir_Great '>'>
                                      fd: 16777215
                                      arg_word: {($ VSub_DollarName '$tmpdir') (/tmp-la)}
                                    )
                                  ]
                                )
                                (C {(mv)} {(-f)} {($ VSub_DollarName '$tmpdir') (/tmp-la)} 
                                  {($ VSub_DollarName '$lib')}
                                )
                              ]
                            )
                        )
                        (C {(${ VSub_Name RM) (r)} {(DQ ($ VSub_DollarName '$tmpdir'))})
                      ]
                    )
                  ]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: 
                        (command.AndOr
                          ops: [Op_DAmp]
                          children: [
                            (C {(test)} {(-n)} 
                              {
                                (DQ ($ VSub_DollarName '$finish_cmds') 
                                  ($ VSub_DollarName '$finish_eval')
                                )
                              }
                            )
                            (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$libdirs'))})
                          ]
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (command.ForEach
                      iter_name: libdir
                      iter_words: [{($ VSub_DollarName '$libdirs')}]
                      do_arg_iter: F
                      body: 
                        (command.DoGroup
                          children: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$finish_cmds'))})
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (C {(func_execute_cmds)} {(DQ ($ VSub_DollarName '$finish_cmds'))} 
                                      {(SQ <'admincmds="$admincmds\n'>) 
                                        (DQ ($ VSub_DollarName '$cmd')) (SQ <'"'>)
                                      }
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$finish_eval'))})
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (C {(eval)} 
                                      {(Lit_VarLike 'cmds=') 
                                        (word_part.EscapedLiteral
                                          token: <Lit_EscapedChar '\\"'>
                                        ) ($ VSub_DollarName '$finish_eval') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>)
                                      }
                                    )
                                    (command.AndOr
                                      ops: [Op_DPipe Op_DPipe]
                                      children: [
                                        (C {($ VSub_DollarName '$opt_dry_run')})
                                        (C {(eval)} {(DQ ($ VSub_DollarName '$cmds'))})
                                        (C {(func_append)} {(admincmds)} 
                                          {(DQ ('\n') ('       ') ($ VSub_DollarName '$cmds'))}
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                            )
                          ]
                        )
                    )
                  ]
                )
              ]
            )
            (command.AndOr
              ops: [Op_DAmp]
              children: [
                (C {($ VSub_DollarName '$opt_quiet')})
                (command.ControlFlow
                  token: <ControlFlow_Exit exit>
                  arg_word: {($ VSub_DollarName '$EXIT_SUCCESS')}
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: 
                        (command.AndOr
                          ops: [Op_DAmp]
                          children: [
                            (C {(test)} {(-n)} 
                              {
                                (DQ ($ VSub_DollarName '$finish_cmds') 
                                  ($ VSub_DollarName '$finish_eval')
                                )
                              }
                            )
                            (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$libdirs'))})
                          ]
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (C {(echo)} 
                      {(DQ (----------------------------------------------------------------------))}
                    )
                    (C {(echo)} {(DQ ('Libraries have been installed in:'))})
                    (command.ForEach
                      iter_name: libdir
                      iter_words: [{($ VSub_DollarName '$libdirs')}]
                      do_arg_iter: F
                      body: 
                        (command.DoGroup
                          children: [
                            (C {($ VSub_DollarName '$ECHO')} 
                              {(DQ ('   ') ($ VSub_DollarName '$libdir'))}
                            )
                          ]
                        )
                    )
                    (C {(echo)})
                    (C {(echo)} 
                      {(DQ ('If you ever happen to want to link against installed libraries'))}
                    )
                    (C {(echo)} 
                      {(DQ ('in a given directory, LIBDIR, you must either use libtool, and'))}
                    )
                    (C {(echo)} 
                      {(DQ ("specify the full pathname of the library, or use the '-LLIBDIR'"))}
                    )
                    (C {(echo)} {(DQ ('flag during linking and do at least one of the following:'))})
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$shlibpath_var'))})
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [
                            (C {(echo)} 
                              {
                                (DQ ("   - add LIBDIR to the '") ($ VSub_DollarName '$shlibpath_var') 
                                  ("' environment variable")
                                )
                              }
                            )
                            (C {(echo)} {(DQ ('     during execution'))})
                          ]
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$runpath_var'))})
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [
                            (C {(echo)} 
                              {
                                (DQ ("   - add LIBDIR to the '") ($ VSub_DollarName '$runpath_var') 
                                  ("' environment variable")
                                )
                              }
                            )
                            (C {(echo)} {(DQ ('     during linking'))})
                          ]
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: 
                                (C {(test)} {(-n)} 
                                  {(DQ ($ VSub_DollarName '$hardcode_libdir_flag_spec'))}
                                )
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:libdir)
                                  op: Equal
                                  rhs: {(LIBDIR)}
                                )
                              ]
                            )
                            (C {(eval)} 
                              {(Lit_VarLike 'flag=') 
                                (word_part.EscapedLiteral
                                  token: <Lit_EscapedChar '\\"'>
                                ) ($ VSub_DollarName '$hardcode_libdir_flag_spec') 
                                (word_part.EscapedLiteral
                                  token: <Lit_EscapedChar '\\"'>
                                )
                              }
                            )
                            (C {($ VSub_DollarName '$ECHO')} 
                              {(DQ ("   - use the '") ($ VSub_DollarName '$flag') ("' linker flag"))}
                            )
                          ]
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$admincmds'))})
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [
                            (C {($ VSub_DollarName '$ECHO')} 
                              {
                                (DQ ('   - have your system administrator run these commands:') 
                                  ($ VSub_DollarName '$admincmds')
                                )
                              }
                            )
                          ]
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: (C {(test)} {(-f)} {(/etc/ld.so.conf)})
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [
                            (C {(echo)} 
                              {
                                (DQ 
                                  (
"   - have your system administrator add LIBDIR to '/etc/ld.so.conf'"
                                  )
                                )
                              }
                            )
                          ]
                        )
                      ]
                    )
                    (C {(echo)})
                    (C {(echo)} 
                      {(DQ ('See any operating system documentation about shared libraries for'))}
                    )
                    (command.Case
                      to_match: {($ VSub_DollarName '$host')}
                      arms: [
                        (case_arm
                          pat_list: [
                            {(solaris2.) (Lit_LBracket '[') (6789) (Lit_RBracket ']')}
                            {(solaris2.1) (Lit_LBracket '[') (0-9) (Lit_RBracket ']')}
                          ]
                          action: [
                            (C {(echo)} 
                              {
                                (DQ 
                                  (
'more information, such as the ld(1), crle(1) and ld.so(8) manual'
                                  )
                                )
                              }
                            )
                            (C {(echo)} {(DQ (pages.))})
                          ]
                        )
                        (case_arm
                          pat_list: [{(Lit_Star '*')}]
                          action: [
                            (C {(echo)} 
                              {
                                (DQ 
                                  ('more information, such as the ld(1) and ld.so(8) manual pages.')
                                )
                              }
                            )
                          ]
                        )
                      ]
                    )
                    (C {(echo)} 
                      {(DQ (----------------------------------------------------------------------))}
                    )
                  ]
                )
              ]
            )
            (command.ControlFlow
              token: <ControlFlow_Exit exit>
              arg_word: {($ VSub_DollarName '$EXIT_SUCCESS')}
            )
          ]
        )
    )
    (command.AndOr
      ops: [Op_DAmp]
      children: [
        (C {(test)} {(finish)} {(Lit_Equals '=')} {(DQ ($ VSub_DollarName '$opt_mode'))})
        (C {(func_mode_finish)} 
          {
            (braced_var_sub
              token: <VSub_Number 1>
              suffix_op: (suffix_op.Unary op_id:VTest_Plus arg_word:{(DQ ($ VSub_At '$@'))})
            )
          }
        )
      ]
    )
    (command.ShFunction
      name: func_mode_install
      body: 
        (command.BraceGroup
          children: [
            (C {($ VSub_DollarName '$debug_cmd')})
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.AndOr
                      ops: [Op_DPipe Op_DPipe]
                      children: [
                        (C {(test)} {(DQ ($ VSub_DollarName '$SHELL'))} {(Lit_Equals '=')} 
                          {(DQ ($ VSub_DollarName '$nonopt'))}
                        )
                        (C {(test)} {(/bin/sh)} {(Lit_Equals '=')} {(DQ ($ VSub_DollarName '$nonopt'))})
                        (command.Case
                          to_match: {($ VSub_DollarName '$nonopt')}
                          arms: [
                            (case_arm
                              pat_list: [{(Lit_Star '*') (shtool) (Lit_Star '*')}]
                              action: [(C {(Lit_Other ':')})]
                            )
                            (case_arm
                              pat_list: [{(Lit_Star '*')}]
                              action: [(C {(false)})]
                            )
                          ]
                        )
                      ]
                    )
                  ]
                  action: [
                    (C {(func_quote_for_eval)} {(DQ ($ VSub_DollarName '$nonopt'))})
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:install_prog)
                          op: Equal
                          rhs: {(DQ ($ VSub_DollarName '$func_quote_for_eval_result') (' '))}
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:arg)
                          op: Equal
                          rhs: {($ VSub_Number '$1')}
                        )
                      ]
                    )
                    (C {(shift)})
                  ]
                )
              ]
              else_action: [
                (command.ShAssignment
                  pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:install_prog) op:Equal rhs:(word.Empty))]
                )
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:arg)
                      op: Equal
                      rhs: {($ VSub_DollarName '$nonopt')}
                    )
                  ]
                )
              ]
            )
            (C {(func_quote_for_eval)} {(DQ ($ VSub_DollarName '$arg'))})
            (C {(func_append)} {(install_prog)} {(DQ ($ VSub_DollarName '$func_quote_for_eval_result'))})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:install_shared_prog)
                  op: Equal
                  rhs: {($ VSub_DollarName '$install_prog')}
                )
              ]
            )
            (command.Case
              to_match: {(DQ (' ') ($ VSub_DollarName '$install_prog') (' '))}
              arms: [
                (case_arm
                  pat_list: [
                    {(Lit_Star '*') (Lit_LBracket '[') 
                      (word_part.EscapedLiteral token:<Lit_EscapedChar '\\\\'>) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\ '>) (/) (Lit_RBracket ']') (cp) 
                      (word_part.EscapedLiteral token:<Lit_EscapedChar '\\ '>) (Lit_Star '*')
                    }
                  ]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:install_cp)
                          op: Equal
                          rhs: {(Lit_Other ':')}
                        )
                      ]
                    )
                  ]
                )
                (case_arm
                  pat_list: [{(Lit_Star '*')}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:install_cp)
                          op: Equal
                          rhs: {(false)}
                        )
                      ]
                    )
                  ]
                )
              ]
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:dest) op:Equal rhs:(word.Empty))]
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:files) op:Equal rhs:(word.Empty))]
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:opts) op:Equal rhs:(word.Empty))]
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:prev) op:Equal rhs:(word.Empty))]
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:install_type) op:Equal rhs:(word.Empty))]
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:isdir) op:Equal rhs:{(false)})]
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:stripme) op:Equal rhs:(word.Empty))]
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:no_mode) op:Equal rhs:{(Lit_Other ':')})]
            )
            (command.ForEach
              iter_name: arg
              do_arg_iter: T
              body: 
                (command.DoGroup
                  children: [
                    (command.ShAssignment
                      pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:arg2) op:Equal rhs:(word.Empty))]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$dest'))})
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [
                            (C {(func_append)} {(files)} {(DQ (' ') ($ VSub_DollarName '$dest'))})
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:dest)
                                  op: Equal
                                  rhs: {($ VSub_DollarName '$arg')}
                                )
                              ]
                            )
                            (command.ControlFlow
                              token: <ControlFlow_Continue continue>
                            )
                          ]
                        )
                      ]
                    )
                    (command.Case
                      to_match: {($ VSub_DollarName '$arg')}
                      arms: [
                        (case_arm
                          pat_list: [{(-d)}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:isdir)
                                  op: Equal
                                  rhs: {(Lit_Other ':')}
                                )
                              ]
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(-f)}]
                          action: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: (C {($ VSub_DollarName '$install_cp')})
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (command.Sentence
                                      child: (C {(Lit_Other ':')})
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                )
                              ]
                              else_action: [
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:prev)
                                      op: Equal
                                      rhs: {($ VSub_DollarName '$arg')}
                                    )
                                  ]
                                )
                              ]
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(-g)} {(-m)} {(-o)}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:prev)
                                  op: Equal
                                  rhs: {($ VSub_DollarName '$arg')}
                                )
                              ]
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(-s)}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:stripme)
                                  op: Equal
                                  rhs: {(DQ (' -s'))}
                                )
                              ]
                            )
                            (command.ControlFlow
                              token: <ControlFlow_Continue continue>
                            )
                          ]
                        )
                        (case_arm pat_list:[{(-) (Lit_Star '*')}])
                        (case_arm
                          pat_list: [{(Lit_Star '*')}]
                          action: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$prev'))})
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (command.Sentence
                                              child: 
                                                (command.AndOr
                                                  ops: [Op_DAmp]
                                                  children: [
                                                    (C {(test)} {(X-m)} {(Lit_Equals '=')} 
                                                      {(DQ (X) ($ VSub_DollarName '$prev'))}
                                                    )
                                                    (C {(test)} {(-n)} 
                                                      {
                                                        (DQ 
                                                          ($ VSub_DollarName '$install_override_mode')
                                                        )
                                                      }
                                                    )
                                                  ]
                                                )
                                              terminator: <Op_Semi ';'>
                                            )
                                          ]
                                          action: [
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:arg2)
                                                  op: Equal
                                                  rhs: {($ VSub_DollarName '$install_override_mode')}
                                                )
                                              ]
                                            )
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:no_mode)
                                                  op: Equal
                                                  rhs: {(false)}
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                    (command.ShAssignment
                                      pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:prev) op:Equal rhs:(word.Empty))]
                                    )
                                  ]
                                )
                              ]
                              else_action: [
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:dest)
                                      op: Equal
                                      rhs: {($ VSub_DollarName '$arg')}
                                    )
                                  ]
                                )
                                (command.ControlFlow
                                  token: <ControlFlow_Continue continue>
                                )
                              ]
                            )
                          ]
                        )
                      ]
                    )
                    (C {(func_quote_for_eval)} {(DQ ($ VSub_DollarName '$arg'))})
                    (C {(func_append)} {(install_prog)} 
                      {(DQ (' ') ($ VSub_DollarName '$func_quote_for_eval_result'))}
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$arg2'))})
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [(C {(func_quote_for_eval)} {(DQ ($ VSub_DollarName '$arg2'))})]
                        )
                      ]
                    )
                    (C {(func_append)} {(install_shared_prog)} 
                      {(DQ (' ') ($ VSub_DollarName '$func_quote_for_eval_result'))}
                    )
                  ]
                )
            )
            (command.AndOr
              ops: [Op_DAmp]
              children: [
                (C {(test)} {(-z)} {(DQ ($ VSub_DollarName '$install_prog'))})
                (C {(func_fatal_help)} {(DQ ('you must specify an install program'))})
              ]
            )
            (command.AndOr
              ops: [Op_DAmp]
              children: [
                (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$prev'))})
                (C {(func_fatal_help)} 
                  {(DQ ("the '") ($ VSub_DollarName '$prev') ("' option requires an argument"))}
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: 
                        (command.AndOr
                          ops: [Op_DAmp]
                          children: [
                            (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$install_override_mode'))})
                            (C {($ VSub_DollarName '$no_mode')})
                          ]
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: (C {($ VSub_DollarName '$install_cp')})
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [
                            (command.Sentence
                              child: (C {(Lit_Other ':')})
                              terminator: <Op_Semi ';'>
                            )
                          ]
                        )
                      ]
                      else_action: [
                        (C {(func_quote_for_eval)} {(DQ ($ VSub_DollarName '$install_override_mode'))})
                        (C {(func_append)} {(install_shared_prog)} 
                          {(DQ (' -m ') ($ VSub_DollarName '$func_quote_for_eval_result'))}
                        )
                      ]
                    )
                  ]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: (C {(test)} {(-z)} {(DQ ($ VSub_DollarName '$files'))})
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: (C {(test)} {(-z)} {(DQ ($ VSub_DollarName '$dest'))})
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [(C {(func_fatal_help)} {(DQ ('no file or destination specified'))})]
                        )
                      ]
                      else_action: [(C {(func_fatal_help)} {(DQ ('you must specify a destination'))})]
                    )
                  ]
                )
              ]
            )
            (C {(func_stripname)} {(SQ )} {(SQ </>)} {(DQ ($ VSub_DollarName '$dest'))})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:dest)
                  op: Equal
                  rhs: {($ VSub_DollarName '$func_stripname_result')}
                )
              ]
            )
            (command.AndOr
              ops: [Op_DAmp]
              children: [
                (C {(test)} {(-d)} {(DQ ($ VSub_DollarName '$dest'))})
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:isdir)
                      op: Equal
                      rhs: {(Lit_Other ':')}
                    )
                  ]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: (C {($ VSub_DollarName '$isdir')})
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:destdir)
                          op: Equal
                          rhs: {($ VSub_DollarName '$dest')}
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:destname) op:Equal rhs:(word.Empty))]
                    )
                  ]
                )
              ]
              else_action: [
                (C {(func_dirname_and_basename)} {(DQ ($ VSub_DollarName '$dest'))} {(DQ )} {(DQ (.))})
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:destdir)
                      op: Equal
                      rhs: {($ VSub_DollarName '$func_dirname_result')}
                    )
                  ]
                )
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:destname)
                      op: Equal
                      rhs: {($ VSub_DollarName '$func_basename_result')}
                    )
                  ]
                )
                (command.Sentence
                  child: (C {(KW_Set set)} {(dummy)} {($ VSub_DollarName '$files')})
                  terminator: <Op_Semi ';'>
                )
                (C {(shift)})
                (command.AndOr
                  ops: [Op_DAmp]
                  children: [
                    (C {(test)} {(DQ ($ VSub_Pound '$#'))} {(-gt)} {(1)})
                    (C {(func_fatal_help)} 
                      {(DQ ("'") ($ VSub_DollarName '$dest') ("' is not a directory"))}
                    )
                  ]
                )
              ]
            )
            (command.Case
              to_match: {($ VSub_DollarName '$destdir')}
              arms: [
                (case_arm
                  pat_list: [
                    {(Lit_LBracket '[') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\\\'>) (/) 
                      (Lit_RBracket ']') (Lit_Star '*')
                    }
                    {(Lit_LBracket '[') (A-Za-z) (Lit_RBracket ']') (Lit_Other ':') (Lit_LBracket '[') 
                      (word_part.EscapedLiteral token:<Lit_EscapedChar '\\\\'>) (/) (Lit_RBracket ']') (Lit_Star '*')
                    }
                  ]
                )
                (case_arm
                  pat_list: [{(Lit_Star '*')}]
                  action: [
                    (command.ForEach
                      iter_name: file
                      iter_words: [{($ VSub_DollarName '$files')}]
                      do_arg_iter: F
                      body: 
                        (command.DoGroup
                          children: [
                            (command.Case
                              to_match: {($ VSub_DollarName '$file')}
                              arms: [
                                (case_arm
                                  pat_list: [{(Lit_Star '*') (.lo)}]
                                )
                                (case_arm
                                  pat_list: [{(Lit_Star '*')}]
                                  action: [
                                    (C {(func_fatal_help)} 
                                      {
                                        (DQ ("'") ($ VSub_DollarName '$destdir') 
                                          ("' must be an absolute directory name")
                                        )
                                      }
                                    )
                                  ]
                                )
                              ]
                            )
                          ]
                        )
                    )
                  ]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:libtool_install_magic)
                  op: Equal
                  rhs: {($ VSub_DollarName '$magic')}
                )
              ]
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:staticlibs) op:Equal rhs:(word.Empty))]
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:future_libdirs) op:Equal rhs:(word.Empty))]
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:current_libdirs) op:Equal rhs:(word.Empty))]
            )
            (command.ForEach
              iter_name: file
              iter_words: [{($ VSub_DollarName '$files')}]
              do_arg_iter: F
              body: 
                (command.DoGroup
                  children: [
                    (command.Case
                      to_match: {($ VSub_DollarName '$file')}
                      arms: [
                        (case_arm
                          pat_list: [{(Lit_Star '*') (.) ($ VSub_DollarName '$libext')}]
                          action: [
                            (C {(func_append)} {(staticlibs)} {(DQ (' ') ($ VSub_DollarName '$file'))})
                          ]
                        )
                        (case_arm
                          pat_list: [{(Lit_Star '*') (.la)}]
                          action: [
                            (C {(func_resolve_sysroot)} {(DQ ($ VSub_DollarName '$file'))})
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:file)
                                  op: Equal
                                  rhs: {($ VSub_DollarName '$func_resolve_sysroot_result')}
                                )
                              ]
                            )
                            (command.AndOr
                              ops: [Op_DPipe]
                              children: [
                                (C {(func_lalib_unsafe_p)} {(DQ ($ VSub_DollarName '$file'))})
                                (C {(func_fatal_help)} 
                                  {
                                    (DQ ("'") ($ VSub_DollarName '$file') 
                                      ("' is not a valid libtool archive")
                                    )
                                  }
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:library_names)
                                  op: Equal
                                  rhs: (word.Empty)
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:old_library) op:Equal rhs:(word.Empty))]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:relink_command)
                                  op: Equal
                                  rhs: (word.Empty)
                                )
                              ]
                            )
                            (C {(func_source)} {(DQ ($ VSub_DollarName '$file'))})
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (C {(test)} {(DQ (X) ($ VSub_DollarName '$destdir'))} 
                                          {(Lit_Equals '=')} {(DQ (X) ($ VSub_DollarName '$libdir'))}
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (command.Case
                                      to_match: {(DQ ($ VSub_DollarName '$current_libdirs') (' '))}
                                      arms: [
                                        (case_arm
                                          pat_list: [
                                            {(Lit_Star '*') 
                                              (DQ (' ') ($ VSub_DollarName '$libdir') (' ')) (Lit_Star '*')
                                            }
                                          ]
                                        )
                                        (case_arm
                                          pat_list: [{(Lit_Star '*')}]
                                          action: [
                                            (C {(func_append)} {(current_libdirs)} 
                                              {(DQ (' ') ($ VSub_DollarName '$libdir'))}
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                              else_action: [
                                (command.Case
                                  to_match: {(DQ ($ VSub_DollarName '$future_libdirs') (' '))}
                                  arms: [
                                    (case_arm
                                      pat_list: [
                                        {(Lit_Star '*') (DQ (' ') ($ VSub_DollarName '$libdir') (' ')) 
                                          (Lit_Star '*')
                                        }
                                      ]
                                    )
                                    (case_arm
                                      pat_list: [{(Lit_Star '*')}]
                                      action: [
                                        (C {(func_append)} {(future_libdirs)} 
                                          {(DQ (' ') ($ VSub_DollarName '$libdir'))}
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                            )
                            (C {(func_dirname)} {(DQ ($ VSub_DollarName '$file'))} {(DQ (/))} {(DQ )})
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:dir)
                                  op: Equal
                                  rhs: {($ VSub_DollarName '$func_dirname_result')}
                                )
                              ]
                            )
                            (C {(func_append)} {(dir)} {(DQ ($ VSub_DollarName '$objdir'))})
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$relink_command'))})
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:inst_prefix_dir)
                                          op: Equal
                                          rhs: 
                                            {
                                              (command_sub
                                                left_token: <Left_Backtick '`'>
                                                command_list: 
                                                  (command.CommandList
                                                    children: [
                                                      (command.Pipeline
                                                        children: [
                                                          (C {($ VSub_DollarName '$ECHO')} 
                                                            {(DQ ($ VSub_DollarName '$destdir'))}
                                                          )
                                                          (C {($ VSub_DollarName '$SED')} {(-e)} 
                                                            {
                                                              (DQ ('s%') ($ VSub_DollarName '$libdir') 
                                                                (Lit_Other '$') ('%%')
                                                              )
                                                            }
                                                          )
                                                        ]
                                                        negated: F
                                                      )
                                                    ]
                                                  )
                                              )
                                            }
                                        )
                                      ]
                                    )
                                    (command.AndOr
                                      ops: [Op_DAmp]
                                      children: [
                                        (C {(test)} {(DQ ($ VSub_DollarName '$inst_prefix_dir'))} 
                                          {(Lit_Equals '=')} {(DQ ($ VSub_DollarName '$destdir'))}
                                        )
                                        (C {(func_fatal_error)} 
                                          {
                                            (DQ ("error: cannot install '") 
                                              ($ VSub_DollarName '$file') ("' to a directory not ending in ") ($ VSub_DollarName '$libdir')
                                            )
                                          }
                                        )
                                      ]
                                    )
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (command.Sentence
                                              child: 
                                                (C {(test)} {(-n)} 
                                                  {(DQ ($ VSub_DollarName '$inst_prefix_dir'))}
                                                )
                                              terminator: <Op_Semi ';'>
                                            )
                                          ]
                                          action: [
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:relink_command)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (command_sub
                                                        left_token: <Left_Backtick '`'>
                                                        command_list: 
                                                          (command.CommandList
                                                            children: [
                                                              (command.Pipeline
                                                                children: [
                                                                  (C {($ VSub_DollarName '$ECHO')} 
                                                                    {
                                                                      (DQ 
                                                                        ($ VSub_DollarName 
'$relink_command'
                                                                        )
                                                                      )
                                                                    }
                                                                  )
                                                                  (C {($ VSub_DollarName '$SED')} 
                                                                    {
                                                                      (DQ 
                                                                        (
's%@inst_prefix_dir@%-inst-prefix-dir '
                                                                        ) ($ VSub_DollarName '$inst_prefix_dir') ('%')
                                                                      )
                                                                    }
                                                                  )
                                                                ]
                                                                negated: F
                                                              )
                                                            ]
                                                          )
                                                      )
                                                    }
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                      ]
                                      else_action: [
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:relink_command)
                                              op: Equal
                                              rhs: 
                                                {
                                                  (command_sub
                                                    left_token: <Left_Backtick '`'>
                                                    command_list: 
                                                      (command.CommandList
                                                        children: [
                                                          (command.Pipeline
                                                            children: [
                                                              (C {($ VSub_DollarName '$ECHO')} 
                                                                {
                                                                  (DQ 
                                                                    ($ VSub_DollarName 
'$relink_command'
                                                                    )
                                                                  )
                                                                }
                                                              )
                                                              (C {($ VSub_DollarName '$SED')} 
                                                                {(DQ ('s%@inst_prefix_dir@%%'))}
                                                              )
                                                            ]
                                                            negated: F
                                                          )
                                                        ]
                                                      )
                                                  )
                                                }
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                    (C {(func_warning)} 
                                      {(DQ ("relinking '") ($ VSub_DollarName '$file') ("'"))}
                                    )
                                    (C {(func_show_eval)} {(DQ ($ VSub_DollarName '$relink_command'))} 
                                      {(SQ <'func_fatal_error "error: relink '>) 
                                        (word_part.EscapedLiteral
                                          token: <Lit_EscapedChar "\\'">
                                        ) (SQ <'$file'>) (word_part.EscapedLiteral token:<Lit_EscapedChar "\\'">) 
                                        (SQ <' with the above command before installing it"'>)
                                      }
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.Sentence
                              child: 
                                (C {(KW_Set set)} {(dummy)} {($ VSub_DollarName '$library_names')})
                              terminator: <Op_Semi ';'>
                            )
                            (C {(shift)})
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: (C {(test)} {(-n)} {(DQ ($ VSub_Number '$1'))})
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:realname)
                                          op: Equal
                                          rhs: {($ VSub_Number '$1')}
                                        )
                                      ]
                                    )
                                    (C {(shift)})
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:srcname)
                                          op: Equal
                                          rhs: {($ VSub_DollarName '$realname')}
                                        )
                                      ]
                                    )
                                    (command.AndOr
                                      ops: [Op_DAmp]
                                      children: [
                                        (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$relink_command'))})
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:srcname)
                                              op: Equal
                                              rhs: {(${ VSub_Name realname) (T)}
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                    (C {(func_show_eval)} 
                                      {
                                        (DQ ($ VSub_DollarName '$install_shared_prog') (' ') 
                                          ($ VSub_DollarName '$dir') (/) ($ VSub_DollarName '$srcname') (' ') ($ VSub_DollarName '$destdir') (/) 
                                          ($ VSub_DollarName '$realname')
                                        )
                                      } {(SQ <'exit $?'>)}
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:tstripme)
                                          op: Equal
                                          rhs: {($ VSub_DollarName '$stripme')}
                                        )
                                      ]
                                    )
                                    (command.Case
                                      to_match: {($ VSub_DollarName '$host_os')}
                                      arms: [
                                        (case_arm
                                          pat_list: [
                                            {(cygwin) (Lit_Star '*')}
                                            {(mingw) (Lit_Star '*')}
                                            {(pw32) (Lit_Star '*')}
                                            {(cegcc) (Lit_Star '*')}
                                          ]
                                          action: [
                                            (command.Case
                                              to_match: {($ VSub_DollarName '$realname')}
                                              arms: [
                                                (case_arm
                                                  pat_list: [{(Lit_Star '*') (.dll.a)}]
                                                  action: [
                                                    (command.ShAssignment
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (sh_lhs_expr.Name name:tstripme)
                                                          op: Equal
                                                          rhs: (word.Empty)
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                        (case_arm
                                          pat_list: [{(os2) (Lit_Star '*')}]
                                          action: [
                                            (command.Case
                                              to_match: {($ VSub_DollarName '$realname')}
                                              arms: [
                                                (case_arm
                                                  pat_list: [{(Lit_Star '*') (_dll.a)}]
                                                  action: [
                                                    (command.ShAssignment
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (sh_lhs_expr.Name name:tstripme)
                                                          op: Equal
                                                          rhs: (word.Empty)
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (command.Sentence
                                              child: 
                                                (command.AndOr
                                                  ops: [Op_DAmp]
                                                  children: [
                                                    (C {(test)} {(-n)} 
                                                      {(DQ ($ VSub_DollarName '$tstripme'))}
                                                    )
                                                    (C {(test)} {(-n)} 
                                                      {(DQ ($ VSub_DollarName '$striplib'))}
                                                    )
                                                  ]
                                                )
                                              terminator: <Op_Semi ';'>
                                            )
                                          ]
                                          action: [
                                            (C {(func_show_eval)} 
                                              {
                                                (DQ ($ VSub_DollarName '$striplib') (' ') 
                                                  ($ VSub_DollarName '$destdir') (/) ($ VSub_DollarName '$realname')
                                                )
                                              } {(SQ <'exit $?'>)}
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (command.Sentence
                                              child: 
                                                (C {(test)} {(DQ ($ VSub_Pound '$#'))} {(-gt)} {(0)})
                                              terminator: <Op_Semi ';'>
                                            )
                                          ]
                                          action: [
                                            (command.ForEach
                                              iter_name: linkname
                                              do_arg_iter: T
                                              body: 
                                                (command.DoGroup
                                                  children: [
                                                    (command.AndOr
                                                      ops: [Op_DAmp]
                                                      children: [
                                                        (C {(test)} 
                                                          {(DQ ($ VSub_DollarName '$linkname'))} {(KW_Bang '!') (Lit_Equals '=')} {(DQ ($ VSub_DollarName '$realname'))}
                                                        )
                                                        (C {(func_show_eval)} 
                                                          {
                                                            (DQ ('(cd ') 
                                                              ($ VSub_DollarName '$destdir') (' && { ') ($ VSub_DollarName '$LN_S') (' -f ') ($ VSub_DollarName '$realname') (' ') 
                                                              ($ VSub_DollarName '$linkname') (' || { ') ($ VSub_DollarName '$RM') (' ') ($ VSub_DollarName '$linkname') (' && ') 
                                                              ($ VSub_DollarName '$LN_S') (' ') ($ VSub_DollarName '$realname') (' ') ($ VSub_DollarName '$linkname') ('; }; })')
                                                            )
                                                          }
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                )
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:lib)
                                          op: Equal
                                          rhs: 
                                            {($ VSub_DollarName '$destdir') (/) 
                                              ($ VSub_DollarName '$realname')
                                            }
                                        )
                                      ]
                                    )
                                    (C {(func_execute_cmds)} 
                                      {(DQ ($ VSub_DollarName '$postinstall_cmds'))} {(SQ <'exit $?'>)}
                                    )
                                  ]
                                )
                              ]
                            )
                            (C {(func_basename)} {(DQ ($ VSub_DollarName '$file'))})
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:name)
                                  op: Equal
                                  rhs: {($ VSub_DollarName '$func_basename_result')}
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:instname)
                                  op: Equal
                                  rhs: {($ VSub_DollarName '$dir') (/) (${ VSub_Name name) (i)}
                                )
                              ]
                            )
                            (C {(func_show_eval)} 
                              {
                                (DQ ($ VSub_DollarName '$install_prog') (' ') 
                                  ($ VSub_DollarName '$instname') (' ') ($ VSub_DollarName '$destdir') (/) ($ VSub_DollarName '$name')
                                )
                              } {(SQ <'exit $?'>)}
                            )
                            (command.AndOr
                              ops: [Op_DAmp]
                              children: [
                                (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$old_library'))})
                                (C {(func_append)} {(staticlibs)} 
                                  {
                                    (DQ (' ') ($ VSub_DollarName '$dir') (/) 
                                      ($ VSub_DollarName '$old_library')
                                    )
                                  }
                                )
                              ]
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(Lit_Star '*') (.lo)}]
                          action: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$destname'))})
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:destfile)
                                          op: Equal
                                          rhs: 
                                            {($ VSub_DollarName '$destdir') (/) 
                                              ($ VSub_DollarName '$destname')
                                            }
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                              else_action: [
                                (C {(func_basename)} {(DQ ($ VSub_DollarName '$file'))})
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:destfile)
                                      op: Equal
                                      rhs: {($ VSub_DollarName '$func_basename_result')}
                                    )
                                  ]
                                )
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:destfile)
                                      op: Equal
                                      rhs: 
                                        {($ VSub_DollarName '$destdir') (/) 
                                          ($ VSub_DollarName '$destfile')
                                        }
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.Case
                              to_match: {($ VSub_DollarName '$destfile')}
                              arms: [
                                (case_arm
                                  pat_list: [{(Lit_Star '*') (.lo)}]
                                  action: [
                                    (C {(func_lo2o)} {(DQ ($ VSub_DollarName '$destfile'))})
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:staticdest)
                                          op: Equal
                                          rhs: {($ VSub_DollarName '$func_lo2o_result')}
                                        )
                                      ]
                                    )
                                  ]
                                )
                                (case_arm
                                  pat_list: [{(Lit_Star '*') (.) ($ VSub_DollarName '$objext')}]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:staticdest)
                                          op: Equal
                                          rhs: {($ VSub_DollarName '$destfile')}
                                        )
                                      ]
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:destfile)
                                          op: Equal
                                          rhs: (word.Empty)
                                        )
                                      ]
                                    )
                                  ]
                                )
                                (case_arm
                                  pat_list: [{(Lit_Star '*')}]
                                  action: [
                                    (C {(func_fatal_help)} 
                                      {
                                        (DQ ("cannot copy a libtool object to '") 
                                          ($ VSub_DollarName '$destfile') ("'")
                                        )
                                      }
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.AndOr
                              ops: [Op_DAmp]
                              children: [
                                (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$destfile'))})
                                (C {(func_show_eval)} 
                                  {
                                    (DQ ($ VSub_DollarName '$install_prog') (' ') 
                                      ($ VSub_DollarName '$file') (' ') ($ VSub_DollarName '$destfile')
                                    )
                                  } {(SQ <'exit $?'>)}
                                )
                              ]
                            )
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (C {(test)} {(yes)} {(Lit_Equals '=')} 
                                          {(DQ ($ VSub_DollarName '$build_old_libs'))}
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (C {(func_lo2o)} {(DQ ($ VSub_DollarName '$file'))})
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:staticobj)
                                          op: Equal
                                          rhs: {($ VSub_DollarName '$func_lo2o_result')}
                                        )
                                      ]
                                    )
                                    (C {(func_show_eval)} 
                                      {
                                        (DQ ($ VSub_DollarName '$install_prog') (' ') 
                                          (word_part.EscapedLiteral
                                            token: <Lit_EscapedChar '\\$'>
                                          ) ('staticobj ') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) (staticdest)
                                        )
                                      } {(SQ <'exit $?'>)}
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.ControlFlow
                              token: <ControlFlow_Exit exit>
                              arg_word: {($ VSub_DollarName '$EXIT_SUCCESS')}
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(Lit_Star '*')}]
                          action: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$destname'))})
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:destfile)
                                          op: Equal
                                          rhs: 
                                            {($ VSub_DollarName '$destdir') (/) 
                                              ($ VSub_DollarName '$destname')
                                            }
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                              else_action: [
                                (C {(func_basename)} {(DQ ($ VSub_DollarName '$file'))})
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:destfile)
                                      op: Equal
                                      rhs: {($ VSub_DollarName '$func_basename_result')}
                                    )
                                  ]
                                )
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:destfile)
                                      op: Equal
                                      rhs: 
                                        {($ VSub_DollarName '$destdir') (/) 
                                          ($ VSub_DollarName '$destfile')
                                        }
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:stripped_ext) op:Equal rhs:(word.Empty))]
                            )
                            (command.Case
                              to_match: {($ VSub_DollarName '$file')}
                              arms: [
                                (case_arm
                                  pat_list: [{(Lit_Star '*') (.exe)}]
                                  action: [
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (command.Sentence
                                              child: 
                                                (C {(test)} {(KW_Bang '!')} {(-f)} 
                                                  {(DQ ($ VSub_DollarName '$file'))}
                                                )
                                              terminator: <Op_Semi ';'>
                                            )
                                          ]
                                          action: [
                                            (C {(func_stripname)} {(SQ )} {(SQ <.exe>)} 
                                              {(DQ ($ VSub_DollarName '$file'))}
                                            )
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:file)
                                                  op: Equal
                                                  rhs: {($ VSub_DollarName '$func_stripname_result')}
                                                )
                                              ]
                                            )
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:stripped_ext)
                                                  op: Equal
                                                  rhs: {(.exe)}
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.Case
                              to_match: {($ VSub_DollarName '$host')}
                              arms: [
                                (case_arm
                                  pat_list: [
                                    {(Lit_Star '*') (cygwin) (Lit_Star '*')}
                                    {(Lit_Star '*') (mingw) (Lit_Star '*')}
                                  ]
                                  action: [
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (command.Sentence
                                              child: 
                                                (C {(func_ltwrapper_executable_p)} 
                                                  {(DQ ($ VSub_DollarName '$file'))}
                                                )
                                              terminator: <Op_Semi ';'>
                                            )
                                          ]
                                          action: [
                                            (C {(func_ltwrapper_scriptname)} 
                                              {(DQ ($ VSub_DollarName '$file'))}
                                            )
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:wrapper)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      ($ VSub_DollarName 
'$func_ltwrapper_scriptname_result'
                                                      )
                                                    }
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                      ]
                                      else_action: [
                                        (C {(func_stripname)} {(SQ )} {(SQ <.exe>)} 
                                          {(DQ ($ VSub_DollarName '$file'))}
                                        )
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:wrapper)
                                              op: Equal
                                              rhs: {($ VSub_DollarName '$func_stripname_result')}
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                  ]
                                )
                                (case_arm
                                  pat_list: [{(Lit_Star '*')}]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:wrapper)
                                          op: Equal
                                          rhs: {($ VSub_DollarName '$file')}
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (C {(func_ltwrapper_script_p)} 
                                          {(DQ ($ VSub_DollarName '$wrapper'))}
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:notinst_deplibs)
                                          op: Equal
                                          rhs: (word.Empty)
                                        )
                                      ]
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:relink_command)
                                          op: Equal
                                          rhs: (word.Empty)
                                        )
                                      ]
                                    )
                                    (C {(func_source)} {(DQ ($ VSub_DollarName '$wrapper'))})
                                    (command.AndOr
                                      ops: [Op_DAmp]
                                      children: [
                                        (C {(test)} {(-z)} 
                                          {(DQ ($ VSub_DollarName '$generated_by_libtool_version'))}
                                        )
                                        (C {(func_fatal_error)} 
                                          {
                                            (DQ ("invalid libtool wrapper script '") 
                                              ($ VSub_DollarName '$wrapper') ("'")
                                            )
                                          }
                                        )
                                      ]
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:finalize)
                                          op: Equal
                                          rhs: {(Lit_Other ':')}
                                        )
                                      ]
                                    )
                                    (command.ForEach
                                      iter_name: lib
                                      iter_words: [{($ VSub_DollarName '$notinst_deplibs')}]
                                      do_arg_iter: F
                                      body: 
                                        (command.DoGroup
                                          children: [
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:libdir)
                                                  op: Equal
                                                  rhs: (word.Empty)
                                                )
                                              ]
                                            )
                                            (command.If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (command.Sentence
                                                      child: 
                                                        (C {(test)} {(-f)} 
                                                          {(DQ ($ VSub_DollarName '$lib'))}
                                                        )
                                                      terminator: <Op_Semi ';'>
                                                    )
                                                  ]
                                                  action: [
                                                    (C {(func_source)} {(DQ ($ VSub_DollarName '$lib'))})
                                                  ]
                                                )
                                              ]
                                            )
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:libfile)
                                                  op: Equal
                                                  rhs: 
                                                    {($ VSub_DollarName '$libdir') (/) 
                                                      (command_sub
                                                        left_token: <Left_Backtick '`'>
                                                        command_list: 
                                                          (command.CommandList
                                                            children: [
                                                              (command.Pipeline
                                                                children: [
                                                                  (C {($ VSub_DollarName '$ECHO')} 
                                                                    {(DQ ($ VSub_DollarName '$lib'))}
                                                                  )
                                                                  (C {($ VSub_DollarName '$SED')} 
                                                                    {(SQ <'s%^.*/%%g'>)}
                                                                  )
                                                                ]
                                                                negated: F
                                                              )
                                                            ]
                                                          )
                                                      )
                                                    }
                                                )
                                              ]
                                            )
                                            (command.If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (command.Sentence
                                                      child: 
                                                        (command.AndOr
                                                          ops: [Op_DAmp]
                                                          children: [
                                                            (C {(test)} {(-n)} 
                                                              {(DQ ($ VSub_DollarName '$libdir'))}
                                                            )
                                                            (C {(test)} {(KW_Bang '!')} {(-f)} 
                                                              {(DQ ($ VSub_DollarName '$libfile'))}
                                                            )
                                                          ]
                                                        )
                                                      terminator: <Op_Semi ';'>
                                                    )
                                                  ]
                                                  action: [
                                                    (C {(func_warning)} 
                                                      {
                                                        (DQ ("'") ($ VSub_DollarName '$lib') 
                                                          ("' has not been installed in '") ($ VSub_DollarName '$libdir') ("'")
                                                        )
                                                      }
                                                    )
                                                    (command.ShAssignment
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (sh_lhs_expr.Name name:finalize)
                                                          op: Equal
                                                          rhs: {(false)}
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:relink_command)
                                          op: Equal
                                          rhs: (word.Empty)
                                        )
                                      ]
                                    )
                                    (C {(func_source)} {(DQ ($ VSub_DollarName '$wrapper'))})
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:outputname)
                                          op: Equal
                                          rhs: (word.Empty)
                                        )
                                      ]
                                    )
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (command.Sentence
                                              child: 
                                                (command.AndOr
                                                  ops: [Op_DAmp]
                                                  children: [
                                                    (C {(test)} {(no)} {(Lit_Equals '=')} 
                                                      {(DQ ($ VSub_DollarName '$fast_install'))}
                                                    )
                                                    (C {(test)} {(-n)} 
                                                      {(DQ ($ VSub_DollarName '$relink_command'))}
                                                    )
                                                  ]
                                                )
                                              terminator: <Op_Semi ';'>
                                            )
                                          ]
                                          action: [
                                            (command.AndOr
                                              ops: [Op_DPipe]
                                              children: [
                                                (C {($ VSub_DollarName '$opt_dry_run')})
                                                (command.BraceGroup
                                                  children: [
                                                    (command.If
                                                      arms: [
                                                        (if_arm
                                                          cond: [
                                                            (command.Sentence
                                                              child: 
                                                                (C {($ VSub_DollarName '$finalize')})
                                                              terminator: <Op_Semi ';'>
                                                            )
                                                          ]
                                                          action: [
                                                            (command.ShAssignment
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: (sh_lhs_expr.Name name:tmpdir)
                                                                  op: Equal
                                                                  rhs: 
                                                                    {
                                                                      (command_sub
                                                                        left_token: 
                                                                          <Left_Backtick '`'>
                                                                        command_list: 
                                                                          (command.CommandList
                                                                            children: [
                                                                              (C {(func_mktempdir)})
                                                                            ]
                                                                          )
                                                                      )
                                                                    }
                                                                )
                                                              ]
                                                            )
                                                            (C {(func_basename)} 
                                                              {
                                                                (DQ ($ VSub_DollarName '$file') 
                                                                  ($ VSub_DollarName '$stripped_ext')
                                                                )
                                                              }
                                                            )
                                                            (command.ShAssignment
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: (sh_lhs_expr.Name name:file)
                                                                  op: Equal
                                                                  rhs: 
                                                                    {
                                                                      ($ VSub_DollarName 
'$func_basename_result'
                                                                      )
                                                                    }
                                                                )
                                                              ]
                                                            )
                                                            (command.ShAssignment
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: 
                                                                    (sh_lhs_expr.Name
                                                                      name: outputname
                                                                    )
                                                                  op: Equal
                                                                  rhs: 
                                                                    {($ VSub_DollarName '$tmpdir') 
                                                                      (/) ($ VSub_DollarName '$file')
                                                                    }
                                                                )
                                                              ]
                                                            )
                                                            (command.ShAssignment
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: 
                                                                    (sh_lhs_expr.Name
                                                                      name: relink_command
                                                                    )
                                                                  op: Equal
                                                                  rhs: 
                                                                    {
                                                                      (command_sub
                                                                        left_token: 
                                                                          <Left_Backtick '`'>
                                                                        command_list: 
                                                                          (command.CommandList
                                                                            children: [
                                                                              (command.Pipeline
                                                                                children: [
                                                                                  (C 
                                                                                    {
                                                                                      ($ 
VSub_DollarName '$ECHO'
                                                                                      )
                                                                                    } {(DQ ($ VSub_DollarName '$relink_command'))}
                                                                                  )
                                                                                  (C 
                                                                                    {
                                                                                      ($ 
VSub_DollarName '$SED'
                                                                                      )
                                                                                    } {(SQ <'s%@OUTPUT@%'>) (DQ ($ VSub_DollarName '$outputname')) (SQ <'%g'>)}
                                                                                  )
                                                                                ]
                                                                                negated: F
                                                                              )
                                                                            ]
                                                                          )
                                                                      )
                                                                    }
                                                                )
                                                              ]
                                                            )
                                                            (command.AndOr
                                                              ops: [Op_DPipe]
                                                              children: [
                                                                (C {($ VSub_DollarName '$opt_quiet')})
                                                                (command.BraceGroup
                                                                  children: [
                                                                    (C {(func_quote_for_expand)} 
                                                                      {
                                                                        (DQ 
                                                                          ($ VSub_DollarName 
'$relink_command'
                                                                          )
                                                                        )
                                                                      }
                                                                    )
                                                                    (C {(eval)} 
                                                                      {
                                                                        (DQ ('func_echo ') 
                                                                          ($ VSub_DollarName 
'$func_quote_for_expand_result'
                                                                          )
                                                                        )
                                                                      }
                                                                    )
                                                                  ]
                                                                )
                                                              ]
                                                            )
                                                            (command.If
                                                              arms: [
                                                                (if_arm
                                                                  cond: [
                                                                    (command.Sentence
                                                                      child: 
                                                                        (C {(eval)} 
                                                                          {
                                                                            (DQ 
                                                                              ($ VSub_DollarName 
'$relink_command'
                                                                              )
                                                                            )
                                                                          }
                                                                        )
                                                                      terminator: <Op_Semi ';'>
                                                                    )
                                                                  ]
                                                                  action: [(C {(Lit_Other ':')})]
                                                                )
                                                              ]
                                                              else_action: [
                                                                (C {(func_error)} 
                                                                  {
                                                                    (DQ ("error: relink '") 
                                                                      ($ VSub_DollarName '$file') ("' with the above command before installing it")
                                                                    )
                                                                  }
                                                                )
                                                                (command.AndOr
                                                                  ops: [Op_DPipe]
                                                                  children: [
                                                                    (C 
                                                                      {
                                                                        ($ VSub_DollarName 
'$opt_dry_run'
                                                                        )
                                                                      }
                                                                    )
                                                                    (C {(${ VSub_Name RM) (r)} 
                                                                      {
                                                                        (DQ 
                                                                          ($ VSub_DollarName 
'$tmpdir'
                                                                          )
                                                                        )
                                                                      }
                                                                    )
                                                                  ]
                                                                )
                                                                (command.ControlFlow
                                                                  token: 
                                                                    <ControlFlow_Continue continue>
                                                                )
                                                              ]
                                                            )
                                                            (command.ShAssignment
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: (sh_lhs_expr.Name name:file)
                                                                  op: Equal
                                                                  rhs: 
                                                                    {
                                                                      ($ VSub_DollarName 
'$outputname'
                                                                      )
                                                                    }
                                                                )
                                                              ]
                                                            )
                                                          ]
                                                        )
                                                      ]
                                                      else_action: [
                                                        (C {(func_warning)} 
                                                          {
                                                            (DQ ("cannot relink '") 
                                                              ($ VSub_DollarName '$file') ("'")
                                                            )
                                                          }
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                      ]
                                      else_action: [
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:file)
                                              op: Equal
                                              rhs: 
                                                {
                                                  (command_sub
                                                    left_token: <Left_Backtick '`'>
                                                    command_list: 
                                                      (command.CommandList
                                                        children: [
                                                          (command.Pipeline
                                                            children: [
                                                              (C {($ VSub_DollarName '$ECHO')} 
                                                                {
                                                                  (DQ ($ VSub_DollarName '$file') 
                                                                    ($ VSub_DollarName 
'$stripped_ext'
                                                                    )
                                                                  )
                                                                }
                                                              )
                                                              (C {($ VSub_DollarName '$SED')} 
                                                                {
                                                                  (DQ ('s%') (Lit_Other '\\') 
                                                                    ('([^/]*') (Lit_Other '\\') (')') (Lit_Other '$') ('%') ($ VSub_DollarName '$objdir') (/) (Lit_Other '\\') ('1%')
                                                                  )
                                                                }
                                                              )
                                                            ]
                                                            negated: F
                                                          )
                                                        ]
                                                      )
                                                  )
                                                }
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.Case
                              to_match: 
                                {($ VSub_DollarName '$install_prog') (Lit_Comma ',') 
                                  ($ VSub_DollarName '$host')
                                }
                              arms: [
                                (case_arm
                                  pat_list: [
                                    {(Lit_Star '*') (/usr/bin/install) (Lit_Star '*') (Lit_Comma ',') 
                                      (Lit_Star '*') (cygwin) (Lit_Star '*')
                                    }
                                  ]
                                  action: [
                                    (command.Case
                                      to_match: 
                                        {($ VSub_DollarName '$file') (Lit_Other ':') 
                                          ($ VSub_DollarName '$destfile')
                                        }
                                      arms: [
                                        (case_arm
                                          pat_list: [
                                            {(Lit_Star '*') (.exe) (Lit_Other ':') (Lit_Star '*') (.exe)}
                                          ]
                                        )
                                        (case_arm
                                          pat_list: [
                                            {(Lit_Star '*') (.exe) (Lit_Other ':') (Lit_Star '*')}
                                          ]
                                          action: [
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:destfile)
                                                  op: Equal
                                                  rhs: {($ VSub_DollarName '$destfile') (.exe)}
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                        (case_arm
                                          pat_list: [
                                            {(Lit_Star '*') (Lit_Other ':') (Lit_Star '*') (.exe)}
                                          ]
                                          action: [
                                            (C {(func_stripname)} {(SQ )} {(SQ <.exe>)} 
                                              {(DQ ($ VSub_DollarName '$destfile'))}
                                            )
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:destfile)
                                                  op: Equal
                                                  rhs: {($ VSub_DollarName '$func_stripname_result')}
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                            )
                            (C {(func_show_eval)} 
                              {
                                (DQ ($ VSub_DollarName '$install_prog') 
                                  (word_part.EscapedLiteral
                                    token: <Lit_EscapedChar '\\$'>
                                  ) ('stripme ') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) ('file ') 
                                  (word_part.EscapedLiteral
                                    token: <Lit_EscapedChar '\\$'>
                                  ) (destfile)
                                )
                              } {(SQ <'exit $?'>)}
                            )
                            (command.AndOr
                              ops: [Op_DPipe]
                              children: [
                                (C {($ VSub_DollarName '$opt_dry_run')})
                                (command.If
                                  arms: [
                                    (if_arm
                                      cond: [
                                        (command.Sentence
                                          child: 
                                            (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$outputname'))})
                                          terminator: <Op_Semi ';'>
                                        )
                                      ]
                                      action: [
                                        (C {(${ VSub_Name RM) (r)} {(DQ ($ VSub_DollarName '$tmpdir'))})
                                      ]
                                    )
                                  ]
                                )
                              ]
                            )
                          ]
                        )
                      ]
                    )
                  ]
                )
            )
            (command.ForEach
              iter_name: file
              iter_words: [{($ VSub_DollarName '$staticlibs')}]
              do_arg_iter: F
              body: 
                (command.DoGroup
                  children: [
                    (C {(func_basename)} {(DQ ($ VSub_DollarName '$file'))})
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:name)
                          op: Equal
                          rhs: {($ VSub_DollarName '$func_basename_result')}
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:oldlib)
                          op: Equal
                          rhs: {($ VSub_DollarName '$destdir') (/) ($ VSub_DollarName '$name')}
                        )
                      ]
                    )
                    (C {(func_to_tool_file)} {(DQ ($ VSub_DollarName '$oldlib'))} 
                      {(func_convert_file_msys_to_w32)}
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:tool_oldlib)
                          op: Equal
                          rhs: {($ VSub_DollarName '$func_to_tool_file_result')}
                        )
                      ]
                    )
                    (C {(func_show_eval)} 
                      {
                        (DQ ($ VSub_DollarName '$install_prog') (' ') 
                          (word_part.EscapedLiteral
                            token: <Lit_EscapedChar '\\$'>
                          ) ('file ') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) (oldlib)
                        )
                      } {(SQ <'exit $?'>)}
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: 
                                (command.AndOr
                                  ops: [Op_DAmp]
                                  children: [
                                    (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$stripme'))})
                                    (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$old_striplib'))})
                                  ]
                                )
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [
                            (C {(func_show_eval)} 
                              {
                                (DQ ($ VSub_DollarName '$old_striplib') (' ') 
                                  ($ VSub_DollarName '$tool_oldlib')
                                )
                              } {(SQ <'exit $?'>)}
                            )
                          ]
                        )
                      ]
                    )
                    (C {(func_execute_cmds)} {(DQ ($ VSub_DollarName '$old_postinstall_cmds'))} 
                      {(SQ <'exit $?'>)}
                    )
                  ]
                )
            )
            (command.AndOr
              ops: [Op_DAmp]
              children: [
                (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$future_libdirs'))})
                (C {(func_warning)} 
                  {
                    (DQ ("remember to run '") ($ VSub_DollarName '$progname') (' --finish') 
                      ($ VSub_DollarName '$future_libdirs') ("'")
                    )
                  }
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$current_libdirs'))})
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (command.AndOr
                      ops: [Op_DAmp]
                      children: [
                        (C {($ VSub_DollarName '$opt_dry_run')})
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:current_libdirs)
                              op: Equal
                              rhs: {(DQ (' -n') ($ VSub_DollarName '$current_libdirs'))}
                            )
                          ]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:exec_cmd)
                          op: Equal
                          rhs: {(SQ <'$SHELL "$progpath" $preserve_args --finish$current_libdirs'>)}
                        )
                      ]
                    )
                  ]
                )
              ]
              else_action: [
                (command.ControlFlow
                  token: <ControlFlow_Exit exit>
                  arg_word: {($ VSub_DollarName '$EXIT_SUCCESS')}
                )
              ]
            )
          ]
        )
    )
    (command.AndOr
      ops: [Op_DAmp]
      children: [
        (C {(test)} {(install)} {(Lit_Equals '=')} {(DQ ($ VSub_DollarName '$opt_mode'))})
        (C {(func_mode_install)} 
          {
            (braced_var_sub
              token: <VSub_Number 1>
              suffix_op: (suffix_op.Unary op_id:VTest_Plus arg_word:{(DQ ($ VSub_At '$@'))})
            )
          }
        )
      ]
    )
    (command.ShFunction
      name: func_generate_dlsyms
      body: 
        (command.BraceGroup
          children: [
            (C {($ VSub_DollarName '$debug_cmd')})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:my_outputname)
                  op: Equal
                  rhs: {($ VSub_Number '$1')}
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:my_originator)
                  op: Equal
                  rhs: {($ VSub_Number '$2')}
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:my_pic_p)
                  op: Equal
                  rhs: 
                    {
                      (braced_var_sub
                        token: <VSub_Number 3>
                        suffix_op: (suffix_op.Unary op_id:VTest_Hyphen arg_word:{(false)})
                      )
                    }
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:my_prefix)
                  op: Equal
                  rhs: 
                    {
                      (command_sub
                        left_token: <Left_Backtick '`'>
                        command_list: 
                          (command.CommandList
                            children: [
                              (command.Pipeline
                                children: [
                                  (C {($ VSub_DollarName '$ECHO')} 
                                    {(DQ ($ VSub_DollarName '$my_originator'))}
                                  )
                                  (C {($ VSub_DollarName '$SED')} {(SQ <'s%[^a-zA-Z0-9]%_%g'>)})
                                ]
                                negated: F
                              )
                            ]
                          )
                      )
                    }
                )
              ]
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:my_dlsyms) op:Equal rhs:(word.Empty))]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: 
                        (command.AndOr
                          ops: [Op_DPipe]
                          children: [
                            (C {(test)} {(-n)} 
                              {(DQ ($ VSub_DollarName '$dlfiles') ($ VSub_DollarName '$dlprefiles'))}
                            )
                            (C {(test)} {(no)} {(KW_Bang '!') (Lit_Equals '=')} 
                              {(DQ ($ VSub_DollarName '$dlself'))}
                            )
                          ]
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: 
                                (command.AndOr
                                  ops: [Op_DAmp]
                                  children: [
                                    (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$NM'))})
                                    (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$global_symbol_pipe'))})
                                  ]
                                )
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:my_dlsyms)
                                  op: Equal
                                  rhs: {(${ VSub_Name my_outputname) (S.c)}
                                )
                              ]
                            )
                          ]
                        )
                      ]
                      else_action: [
                        (C {(func_error)} 
                          {(DQ ('not configured to extract global symbols from dlpreopened files'))}
                        )
                      ]
                    )
                  ]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$my_dlsyms'))})
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (command.Case
                      to_match: {($ VSub_DollarName '$my_dlsyms')}
                      arms: [
                        (case_arm pat_list:[{(DQ )}])
                        (case_arm
                          pat_list: [{(Lit_Star '*') (.c)}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:nlist)
                                  op: Equal
                                  rhs: 
                                    {($ VSub_DollarName '$output_objdir') (/) 
                                      ($ VSub_DollarName '$my_outputname') (.nm)
                                    }
                                )
                              ]
                            )
                            (C {(func_show_eval)} 
                              {
                                (DQ ($ VSub_DollarName '$RM') (' ') ($ VSub_DollarName '$nlist') (' ') 
                                  (${ VSub_Name nlist) ('S ') (${ VSub_Name nlist) (T)
                                )
                              }
                            )
                            (C {(func_verbose)} 
                              {
                                (DQ ('creating ') ($ VSub_DollarName '$output_objdir') (/) 
                                  ($ VSub_DollarName '$my_dlsyms')
                                )
                              }
                            )
                            (command.AndOr
                              ops: [Op_DPipe]
                              children: [
                                (C {($ VSub_DollarName '$opt_dry_run')})
                                (command.Simple
                                  words: [
                                    {($ VSub_DollarName '$ECHO')}
                                    {
                                      (DQ ('/* ') ($ VSub_DollarName '$my_dlsyms') 
                                        (" - symbol resolution table for '") ($ VSub_DollarName '$my_outputname') ("' dlsym emulation. */\n") ('/* Generated by ') 
                                        ($ VSub_DollarName '$PROGRAM') (' (GNU ') ($ VSub_DollarName '$PACKAGE') (') ') ($ VSub_DollarName '$VERSION') (' */\n') ('\n') 
                                        ('#ifdef __cplusplus\n') ('extern ') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) (C) 
                                        (word_part.EscapedLiteral
                                          token: <Lit_EscapedChar '\\"'>
                                        ) (' {\n') ('#endif\n') ('\n') 
                                        (
'#if defined __GNUC__ && (((__GNUC__ == 4) && (__GNUC_MINOR__ >= 4)) || (__GNUC__ > 4))\n'
                                        ) ('#pragma GCC diagnostic ignored ') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) 
                                        (-Wstrict-prototypes) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) ('\n') ('#endif\n') ('\n') 
                                        (
'/* Keep this code in sync between libtool.m4, ltmain, lt_system.h, and tests.  */\n'
                                        ) ('#if defined _WIN32 || defined __CYGWIN__ || defined _WIN32_WCE\n') 
                                        (
"/* DATA imports from DLLs on WIN32 can't be const, because runtime\n"
                                        ) ("   relocations are performed -- see ld's documentation on pseudo-relocs.  */\n") 
                                        ('# define LT_DLSYM_CONST\n') ('#elif defined __osf__\n') 
                                        (
'/* This system does not cope well with relocations in const data.  */\n'
                                        ) ('# define LT_DLSYM_CONST\n') ('#else\n') ('# define LT_DLSYM_CONST const\n') ('#endif\n') ('\n') 
                                        ('#define STREQ(s1, s2) (strcmp ((s1), (s2)) == 0)\n') ('\n') ('/* External symbol declarations for the compiler. */')
                                      )
                                    }
                                  ]
                                  redirects: [
                                    (redir.Redir
                                      op: <Redir_Great '>'>
                                      fd: 16777215
                                      arg_word: 
                                        {
                                          (DQ ($ VSub_DollarName '$output_objdir') (/) 
                                            ($ VSub_DollarName '$my_dlsyms')
                                          )
                                        }
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (C {(test)} {(yes)} {(Lit_Equals '=')} 
                                          {(DQ ($ VSub_DollarName '$dlself'))}
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (C {(func_verbose)} 
                                      {
                                        (DQ ("generating symbol list for '") 
                                          ($ VSub_DollarName '$output') ("'")
                                        )
                                      }
                                    )
                                    (command.AndOr
                                      ops: [Op_DPipe]
                                      children: [
                                        (C {($ VSub_DollarName '$opt_dry_run')})
                                        (command.Simple
                                          words: [{(echo)} {(SQ <': @PROGRAM@ '>)}]
                                          redirects: [
                                            (redir.Redir
                                              op: <Redir_Great '>'>
                                              fd: 16777215
                                              arg_word: {(DQ ($ VSub_DollarName '$nlist'))}
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:progfiles)
                                          op: Equal
                                          rhs: 
                                            {
                                              (command_sub
                                                left_token: <Left_Backtick '`'>
                                                command_list: 
                                                  (command.CommandList
                                                    children: [
                                                      (command.Pipeline
                                                        children: [
                                                          (C {($ VSub_DollarName '$ECHO')} 
                                                            {
                                                              (DQ ($ VSub_DollarName '$objs') 
                                                                ($ VSub_DollarName '$old_deplibs')
                                                              )
                                                            }
                                                          )
                                                          (C {($ VSub_DollarName '$SP2NL')})
                                                          (C {($ VSub_DollarName '$SED')} 
                                                            {(DQ ($ VSub_DollarName '$lo2o'))}
                                                          )
                                                          (C {($ VSub_DollarName '$NL2SP')})
                                                        ]
                                                        negated: F
                                                      )
                                                    ]
                                                  )
                                              )
                                            }
                                        )
                                      ]
                                    )
                                    (command.ForEach
                                      iter_name: progfile
                                      iter_words: [{($ VSub_DollarName '$progfiles')}]
                                      do_arg_iter: F
                                      body: 
                                        (command.DoGroup
                                          children: [
                                            (C {(func_to_tool_file)} 
                                              {(DQ ($ VSub_DollarName '$progfile'))} {(func_convert_file_msys_to_w32)}
                                            )
                                            (C {(func_verbose)} 
                                              {
                                                (DQ ("extracting global C symbols from '") 
                                                  ($ VSub_DollarName '$func_to_tool_file_result') ("'")
                                                )
                                              }
                                            )
                                            (command.AndOr
                                              ops: [Op_DPipe]
                                              children: [
                                                (C {($ VSub_DollarName '$opt_dry_run')})
                                                (C {(eval)} 
                                                  {
                                                    (DQ ($ VSub_DollarName '$NM') (' ') 
                                                      ($ VSub_DollarName '$func_to_tool_file_result') (' | ') ($ VSub_DollarName '$global_symbol_pipe') (" >> '") ($ VSub_DollarName '$nlist') ("'")
                                                    )
                                                  }
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                    )
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (command.Sentence
                                              child: 
                                                (C {(test)} {(-n)} 
                                                  {(DQ ($ VSub_DollarName '$exclude_expsyms'))}
                                                )
                                              terminator: <Op_Semi ';'>
                                            )
                                          ]
                                          action: [
                                            (command.AndOr
                                              ops: [Op_DPipe]
                                              children: [
                                                (C {($ VSub_DollarName '$opt_dry_run')})
                                                (command.BraceGroup
                                                  children: [
                                                    (C {(eval)} 
                                                      {
                                                        (SQ 
                                                          <
'$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T'
                                                          >
                                                        )
                                                      }
                                                    )
                                                    (C {(eval)} {(SQ <'$MV "$nlist"T "$nlist"'>)})
                                                  ]
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (command.Sentence
                                              child: 
                                                (C {(test)} {(-n)} 
                                                  {(DQ ($ VSub_DollarName '$export_symbols_regex'))}
                                                )
                                              terminator: <Op_Semi ';'>
                                            )
                                          ]
                                          action: [
                                            (command.AndOr
                                              ops: [Op_DPipe]
                                              children: [
                                                (C {($ VSub_DollarName '$opt_dry_run')})
                                                (command.BraceGroup
                                                  children: [
                                                    (C {(eval)} 
                                                      {
                                                        (SQ 
                                                          <
'$EGREP -e "$export_symbols_regex" "$nlist" > "$nlist"T'
                                                          >
                                                        )
                                                      }
                                                    )
                                                    (C {(eval)} {(SQ <'$MV "$nlist"T "$nlist"'>)})
                                                  ]
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (command.Sentence
                                              child: 
                                                (C {(test)} {(-z)} 
                                                  {(DQ ($ VSub_DollarName '$export_symbols'))}
                                                )
                                              terminator: <Op_Semi ';'>
                                            )
                                          ]
                                          action: [
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:export_symbols)
                                                  op: Equal
                                                  rhs: 
                                                    {($ VSub_DollarName '$output_objdir') (/) 
                                                      ($ VSub_DollarName '$outputname') (.exp)
                                                    }
                                                )
                                              ]
                                            )
                                            (command.AndOr
                                              ops: [Op_DPipe]
                                              children: [
                                                (C {($ VSub_DollarName '$opt_dry_run')})
                                                (command.BraceGroup
                                                  children: [
                                                    (C {($ VSub_DollarName '$RM')} 
                                                      {($ VSub_DollarName '$export_symbols')}
                                                    )
                                                    (C {(eval)} 
                                                      {
                                                        (DQ ($ VSub_DollarName '$SED') 
                                                          (" -n -e '/^: @PROGRAM@ ") (Lit_Other '$') ("/d' -e 's/^.* ") (Lit_Other '\\') ('(.*') (Lit_Other '\\') (')') (Lit_Other '$') (/) 
                                                          (Lit_Other '\\') ("1/p' ")
                                                        ) (SQ <'< "$nlist" > "$export_symbols"'>)
                                                      }
                                                    )
                                                    (command.Case
                                                      to_match: {($ VSub_DollarName '$host')}
                                                      arms: [
                                                        (case_arm
                                                          pat_list: [
                                                            {(Lit_Star '*') (cygwin) (Lit_Star '*')}
                                                            {(Lit_Star '*') (mingw) (Lit_Star '*')}
                                                            {(Lit_Star '*') (cegcc) (Lit_Star '*')}
                                                          ]
                                                          action: [
                                                            (C {(eval)} 
                                                              {(DQ ('echo EXPORTS ')) 
                                                                (SQ 
                                                                  <
'> "$output_objdir/$outputname.def"'
                                                                  >
                                                                )
                                                              }
                                                            )
                                                            (C {(eval)} 
                                                              {
                                                                (SQ 
                                                                  <
'cat "$export_symbols" >> "$output_objdir/$outputname.def"'
                                                                  >
                                                                )
                                                              }
                                                            )
                                                          ]
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                      ]
                                      else_action: [
                                        (command.AndOr
                                          ops: [Op_DPipe]
                                          children: [
                                            (C {($ VSub_DollarName '$opt_dry_run')})
                                            (command.BraceGroup
                                              children: [
                                                (C {(eval)} 
                                                  {
                                                    (DQ ($ VSub_DollarName '$SED') (" -e 's/") 
                                                      (Lit_Other '\\') ('([].[*^') (Lit_Other '$') (']') (Lit_Other '\\') (')/') 
                                                      (word_part.EscapedLiteral
                                                        token: <Lit_EscapedChar '\\\\'>
                                                      ) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\\\'>) (Lit_Other '\\') ("1/g' -e 's/^/ /' -e 's/") 
                                                      (Lit_Other '$') (/) (Lit_Other '$') ("/'")
                                                    ) (SQ <' < "$export_symbols" > "$output_objdir/$outputname.exp"'>)
                                                  }
                                                )
                                                (C {(eval)} 
                                                  {
                                                    (SQ 
                                                      <
'$GREP -f "$output_objdir/$outputname.exp" < "$nlist" > "$nlist"T'
                                                      >
                                                    )
                                                  }
                                                )
                                                (C {(eval)} {(SQ <'$MV "$nlist"T "$nlist"'>)})
                                                (command.Case
                                                  to_match: {($ VSub_DollarName '$host')}
                                                  arms: [
                                                    (case_arm
                                                      pat_list: [
                                                        {(Lit_Star '*') (cygwin) (Lit_Star '*')}
                                                        {(Lit_Star '*') (mingw) (Lit_Star '*')}
                                                        {(Lit_Star '*') (cegcc) (Lit_Star '*')}
                                                      ]
                                                      action: [
                                                        (C {(eval)} 
                                                          {(DQ ('echo EXPORTS ')) 
                                                            (SQ 
                                                              <'> "$output_objdir/$outputname.def"'>
                                                            )
                                                          }
                                                        )
                                                        (C {(eval)} 
                                                          {
                                                            (SQ 
                                                              <
'cat "$nlist" >> "$output_objdir/$outputname.def"'
                                                              >
                                                            )
                                                          }
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.ForEach
                              iter_name: dlprefile
                              iter_words: [{($ VSub_DollarName '$dlprefiles')}]
                              do_arg_iter: F
                              body: 
                                (command.DoGroup
                                  children: [
                                    (C {(func_verbose)} 
                                      {
                                        (DQ ("extracting global C symbols from '") 
                                          ($ VSub_DollarName '$dlprefile') ("'")
                                        )
                                      }
                                    )
                                    (C {(func_basename)} {(DQ ($ VSub_DollarName '$dlprefile'))})
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:name)
                                          op: Equal
                                          rhs: {($ VSub_DollarName '$func_basename_result')}
                                        )
                                      ]
                                    )
                                    (command.Case
                                      to_match: {($ VSub_DollarName '$host')}
                                      arms: [
                                        (case_arm
                                          pat_list: [
                                            {(Lit_Star '*') (cygwin) (Lit_Star '*')}
                                            {(Lit_Star '*') (mingw) (Lit_Star '*')}
                                            {(Lit_Star '*') (cegcc) (Lit_Star '*')}
                                          ]
                                          action: [
                                            (command.If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (command.Sentence
                                                      child: 
                                                        (C {(func_win32_import_lib_p)} 
                                                          {(DQ ($ VSub_DollarName '$dlprefile'))}
                                                        )
                                                      terminator: <Op_Semi ';'>
                                                    )
                                                  ]
                                                  action: [
                                                    (C {(func_tr_sh)} 
                                                      {(DQ ($ VSub_DollarName '$dlprefile'))}
                                                    )
                                                    (C {(eval)} 
                                                      {
                                                        (DQ ('curr_lafile=') 
                                                          (word_part.EscapedLiteral
                                                            token: <Lit_EscapedChar '\\$'>
                                                          ) (libfile_) ($ VSub_DollarName '$func_tr_sh_result')
                                                        )
                                                      }
                                                    )
                                                    (command.ShAssignment
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: 
                                                            (sh_lhs_expr.Name
                                                              name: dlprefile_dlbasename
                                                            )
                                                          op: Equal
                                                          rhs: (word.Empty)
                                                        )
                                                      ]
                                                    )
                                                    (command.If
                                                      arms: [
                                                        (if_arm
                                                          cond: [
                                                            (command.Sentence
                                                              child: 
                                                                (command.AndOr
                                                                  ops: [Op_DAmp]
                                                                  children: [
                                                                    (C {(test)} {(-n)} 
                                                                      {
                                                                        (DQ 
                                                                          ($ VSub_DollarName 
'$curr_lafile'
                                                                          )
                                                                        )
                                                                      }
                                                                    )
                                                                    (C {(func_lalib_p)} 
                                                                      {
                                                                        (DQ 
                                                                          ($ VSub_DollarName 
'$curr_lafile'
                                                                          )
                                                                        )
                                                                      }
                                                                    )
                                                                  ]
                                                                )
                                                              terminator: <Op_Semi ';'>
                                                            )
                                                          ]
                                                          action: [
                                                            (command.ShAssignment
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: 
                                                                    (sh_lhs_expr.Name
                                                                      name: dlprefile_dlname
                                                                    )
                                                                  op: Equal
                                                                  rhs: 
                                                                    {
                                                                      (command_sub
                                                                        left_token: 
                                                                          <Left_Backtick '`'>
                                                                        command_list: 
                                                                          (command.CommandList
                                                                            children: [
                                                                              (command.AndOr
                                                                                ops: [Op_DAmp]
                                                                                children: [
                                                                                  (C {(source)} 
                                                                                    {
                                                                                      (DQ 
                                                                                        ($ 
VSub_DollarName '$curr_lafile'
                                                                                        )
                                                                                      )
                                                                                    }
                                                                                  )
                                                                                  (C {(echo)} 
                                                                                    {
                                                                                      (DQ 
                                                                                        ($ 
VSub_DollarName '$dlname'
                                                                                        )
                                                                                      )
                                                                                    }
                                                                                  )
                                                                                ]
                                                                              )
                                                                            ]
                                                                          )
                                                                      )
                                                                    }
                                                                )
                                                              ]
                                                            )
                                                            (command.If
                                                              arms: [
                                                                (if_arm
                                                                  cond: [
                                                                    (command.Sentence
                                                                      child: 
                                                                        (C {(test)} {(-n)} 
                                                                          {
                                                                            (DQ 
                                                                              ($ VSub_DollarName 
'$dlprefile_dlname'
                                                                              )
                                                                            )
                                                                          }
                                                                        )
                                                                      terminator: <Op_Semi ';'>
                                                                    )
                                                                  ]
                                                                  action: [
                                                                    (C {(func_basename)} 
                                                                      {
                                                                        (DQ 
                                                                          ($ VSub_DollarName 
'$dlprefile_dlname'
                                                                          )
                                                                        )
                                                                      }
                                                                    )
                                                                    (command.ShAssignment
                                                                      pairs: [
                                                                        (assign_pair
                                                                          lhs: 
                                                                            (sh_lhs_expr.Name
                                                                              name: 
dlprefile_dlbasename
                                                                            )
                                                                          op: Equal
                                                                          rhs: 
                                                                            {
                                                                              ($ VSub_DollarName 
'$func_basename_result'
                                                                              )
                                                                            }
                                                                        )
                                                                      ]
                                                                    )
                                                                  ]
                                                                )
                                                              ]
                                                              else_action: [
                                                                (C 
                                                                  {
                                                                    ($ VSub_DollarName 
'$sharedlib_from_linklib_cmd'
                                                                    )
                                                                  } {(DQ ($ VSub_DollarName '$dlprefile'))}
                                                                )
                                                                (command.ShAssignment
                                                                  pairs: [
                                                                    (assign_pair
                                                                      lhs: 
                                                                        (sh_lhs_expr.Name
                                                                          name: dlprefile_dlbasename
                                                                        )
                                                                      op: Equal
                                                                      rhs: 
                                                                        {
                                                                          ($ VSub_DollarName 
'$sharedlib_from_linklib_result'
                                                                          )
                                                                        }
                                                                    )
                                                                  ]
                                                                )
                                                              ]
                                                            )
                                                          ]
                                                        )
                                                      ]
                                                    )
                                                    (command.AndOr
                                                      ops: [Op_DPipe]
                                                      children: [
                                                        (C {($ VSub_DollarName '$opt_dry_run')})
                                                        (command.BraceGroup
                                                          children: [
                                                            (command.If
                                                              arms: [
                                                                (if_arm
                                                                  cond: [
                                                                    (command.Sentence
                                                                      child: 
                                                                        (C {(test)} {(-n)} 
                                                                          {
                                                                            (DQ 
                                                                              ($ VSub_DollarName 
'$dlprefile_dlbasename'
                                                                              )
                                                                            )
                                                                          }
                                                                        )
                                                                      terminator: <Op_Semi ';'>
                                                                    )
                                                                  ]
                                                                  action: [
                                                                    (C {(eval)} 
                                                                      {
                                                                        (SQ 
                                                                          <
'$ECHO ": $dlprefile_dlbasename" >> "$nlist"'
                                                                          >
                                                                        )
                                                                      }
                                                                    )
                                                                  ]
                                                                )
                                                              ]
                                                              else_action: [
                                                                (C {(func_warning)} 
                                                                  {
                                                                    (DQ 
                                                                      (
'Could not compute DLL name from '
                                                                      ) ($ VSub_DollarName '$name')
                                                                    )
                                                                  }
                                                                )
                                                                (C {(eval)} 
                                                                  {
                                                                    (SQ 
                                                                      <
'$ECHO ": $name " >> "$nlist"'
                                                                      >
                                                                    )
                                                                  }
                                                                )
                                                              ]
                                                            )
                                                            (C {(func_to_tool_file)} 
                                                              {(DQ ($ VSub_DollarName '$dlprefile'))} {(func_convert_file_msys_to_w32)}
                                                            )
                                                            (C {(eval)} 
                                                              {
                                                                (DQ ($ VSub_DollarName '$NM') (' ') 
                                                                  (word_part.EscapedLiteral
                                                                    token: <Lit_EscapedChar '\\"'>
                                                                  ) ($ VSub_DollarName '$func_to_tool_file_result') 
                                                                  (word_part.EscapedLiteral
                                                                    token: <Lit_EscapedChar '\\"'>
                                                                  ) (' 2>/dev/null | ') ($ VSub_DollarName '$global_symbol_pipe') (' |\n') ('\t            ') 
                                                                  ($ VSub_DollarName '$SED') (" -e '/I __imp/d' -e 's/I __nm_/D /;s/_nm__//' >> '") ($ VSub_DollarName '$nlist') ("'")
                                                                )
                                                              }
                                                            )
                                                          ]
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                )
                                              ]
                                              else_action: [
                                                (command.AndOr
                                                  ops: [Op_DPipe]
                                                  children: [
                                                    (C {($ VSub_DollarName '$opt_dry_run')})
                                                    (command.BraceGroup
                                                      children: [
                                                        (C {(eval)} 
                                                          {(SQ <'$ECHO ": $name " >> "$nlist"'>)}
                                                        )
                                                        (C {(func_to_tool_file)} 
                                                          {(DQ ($ VSub_DollarName '$dlprefile'))} {(func_convert_file_msys_to_w32)}
                                                        )
                                                        (C {(eval)} 
                                                          {
                                                            (DQ ($ VSub_DollarName '$NM') (' ') 
                                                              (word_part.EscapedLiteral
                                                                token: <Lit_EscapedChar '\\"'>
                                                              ) ($ VSub_DollarName '$func_to_tool_file_result') 
                                                              (word_part.EscapedLiteral
                                                                token: <Lit_EscapedChar '\\"'>
                                                              ) (' 2>/dev/null | ') ($ VSub_DollarName '$global_symbol_pipe') (" >> '") ($ VSub_DollarName '$nlist') 
                                                              ("'")
                                                            )
                                                          }
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                        (case_arm
                                          pat_list: [{(Lit_Star '*')}]
                                          action: [
                                            (command.AndOr
                                              ops: [Op_DPipe]
                                              children: [
                                                (C {($ VSub_DollarName '$opt_dry_run')})
                                                (command.BraceGroup
                                                  children: [
                                                    (C {(eval)} {(SQ <'$ECHO ": $name " >> "$nlist"'>)})
                                                    (C {(func_to_tool_file)} 
                                                      {(DQ ($ VSub_DollarName '$dlprefile'))} {(func_convert_file_msys_to_w32)}
                                                    )
                                                    (C {(eval)} 
                                                      {
                                                        (DQ ($ VSub_DollarName '$NM') (' ') 
                                                          (word_part.EscapedLiteral
                                                            token: <Lit_EscapedChar '\\"'>
                                                          ) ($ VSub_DollarName '$func_to_tool_file_result') 
                                                          (word_part.EscapedLiteral
                                                            token: <Lit_EscapedChar '\\"'>
                                                          ) (' 2>/dev/null | ') ($ VSub_DollarName '$global_symbol_pipe') (" >> '") ($ VSub_DollarName '$nlist') 
                                                          ("'")
                                                        )
                                                      }
                                                    )
                                                  ]
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                  ]
                                )
                            )
                            (command.AndOr
                              ops: [Op_DPipe]
                              children: [
                                (C {($ VSub_DollarName '$opt_dry_run')})
                                (command.BraceGroup
                                  children: [
                                    (command.AndOr
                                      ops: [Op_DPipe]
                                      children: [
                                        (C {(test)} {(-f)} {(DQ ($ VSub_DollarName '$nlist'))})
                                        (command.Simple
                                          words: [{(Lit_Other ':')}]
                                          redirects: [
                                            (redir.Redir
                                              op: <Redir_Great '>'>
                                              fd: 16777215
                                              arg_word: {(DQ ($ VSub_DollarName '$nlist'))}
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (command.Sentence
                                              child: 
                                                (C {(test)} {(-n)} 
                                                  {(DQ ($ VSub_DollarName '$exclude_expsyms'))}
                                                )
                                              terminator: <Op_Semi ';'>
                                            )
                                          ]
                                          action: [
                                            (command.Simple
                                              words: [
                                                {($ VSub_DollarName '$EGREP')}
                                                {(-v)}
                                                {
                                                  (DQ (' (') ($ VSub_DollarName '$exclude_expsyms') 
                                                    (')') (Lit_Other '$')
                                                  )
                                                }
                                                {(DQ ($ VSub_DollarName '$nlist'))}
                                              ]
                                              redirects: [
                                                (redir.Redir
                                                  op: <Redir_Great '>'>
                                                  fd: 16777215
                                                  arg_word: {(DQ ($ VSub_DollarName '$nlist')) (T)}
                                                )
                                              ]
                                            )
                                            (C {($ VSub_DollarName '$MV')} 
                                              {(DQ ($ VSub_DollarName '$nlist')) (T)} {(DQ ($ VSub_DollarName '$nlist'))}
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (command.Sentence
                                              child: 
                                                (command.Pipeline
                                                  children: [
                                                    (command.Simple
                                                      words: [
                                                        {($ VSub_DollarName '$GREP')}
                                                        {(-v)}
                                                        {(DQ ('^: '))}
                                                      ]
                                                      redirects: [
                                                        (redir.Redir
                                                          op: <Redir_Less '<'>
                                                          fd: 16777215
                                                          arg_word: {(DQ ($ VSub_DollarName '$nlist'))}
                                                        )
                                                      ]
                                                    )
                                                    (command.If
                                                      arms: [
                                                        (if_arm
                                                          cond: [
                                                            (command.Sentence
                                                              child: 
                                                                (command.Simple
                                                                  words: [{(sort)} {(-k)} {(3)}]
                                                                  redirects: [
                                                                    (redir.Redir
                                                                      op: <Redir_Less '<'>
                                                                      fd: 16777215
                                                                      arg_word: {(/dev/null)}
                                                                    )
                                                                    (redir.Redir
                                                                      op: <Redir_Great '>'>
                                                                      fd: 16777215
                                                                      arg_word: {(/dev/null)}
                                                                    )
                                                                    (redir.Redir
                                                                      op: <Redir_GreatAnd '2>&'>
                                                                      fd: 2
                                                                      arg_word: {(1)}
                                                                    )
                                                                  ]
                                                                )
                                                              terminator: <Op_Semi ';'>
                                                            )
                                                          ]
                                                          action: [(C {(sort)} {(-k)} {(3)})]
                                                        )
                                                      ]
                                                      else_action: [(C {(sort)} {(Lit_Other '+') (2)})]
                                                    )
                                                    (command.Simple
                                                      words: [{(uniq)}]
                                                      redirects: [
                                                        (redir.Redir
                                                          op: <Redir_Great '>'>
                                                          fd: 16777215
                                                          arg_word: 
                                                            {(DQ ($ VSub_DollarName '$nlist')) (S)}
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                  negated: F
                                                )
                                              terminator: <Op_Semi ';'>
                                            )
                                          ]
                                          action: [(C {(Lit_Other ':')})]
                                        )
                                      ]
                                      else_action: [
                                        (command.Simple
                                          words: [{($ VSub_DollarName '$GREP')} {(-v)} {(DQ ('^: '))}]
                                          redirects: [
                                            (redir.Redir
                                              op: <Redir_Less '<'>
                                              fd: 16777215
                                              arg_word: {(DQ ($ VSub_DollarName '$nlist'))}
                                            )
                                            (redir.Redir
                                              op: <Redir_Great '>'>
                                              fd: 16777215
                                              arg_word: {(DQ ($ VSub_DollarName '$nlist')) (S)}
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (command.Sentence
                                              child: 
                                                (C {(test)} {(-f)} 
                                                  {(DQ ($ VSub_DollarName '$nlist')) (S)}
                                                )
                                              terminator: <Op_Semi ';'>
                                            )
                                          ]
                                          action: [
                                            (C {(eval)} 
                                              {(DQ ($ VSub_DollarName '$global_symbol_to_cdecl')) 
                                                (SQ <' < "$nlist"S >> "$output_objdir/$my_dlsyms"'>)
                                              }
                                            )
                                          ]
                                        )
                                      ]
                                      else_action: [
                                        (command.Simple
                                          words: [{(echo)} {(SQ <'/* NONE */'>)}]
                                          redirects: [
                                            (redir.Redir
                                              op: <Redir_DGreat '>>'>
                                              fd: 16777215
                                              arg_word: 
                                                {
                                                  (DQ ($ VSub_DollarName '$output_objdir') (/) 
                                                    ($ VSub_DollarName '$my_dlsyms')
                                                  )
                                                }
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                    (C {(func_show_eval)} {(SQ <'$RM "${nlist}I"'>)})
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (command.Sentence
                                              child: 
                                                (C {(test)} {(-n)} 
                                                  {
                                                    (DQ 
                                                      ($ VSub_DollarName '$global_symbol_to_import')
                                                    )
                                                  }
                                                )
                                              terminator: <Op_Semi ';'>
                                            )
                                          ]
                                          action: [
                                            (C {(eval)} 
                                              {(DQ ($ VSub_DollarName '$global_symbol_to_import')) 
                                                (SQ <' < "$nlist"S > "$nlist"I'>)
                                              }
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                    (command.Simple
                                      words: [
                                        {(echo)}
                                        {
                                          (DQ ('\n') 
                                            (
'/* The mapping between symbol names and symbols.  */\n'
                                            ) ('typedef struct {\n') ('  const char *name;\n') ('  void *address;\n') ('} lt_dlsymlist;\n') 
                                            ('extern LT_DLSYM_CONST lt_dlsymlist\n') (lt_) (${ VSub_Name my_prefix) ('_LTX_preloaded_symbols[];')
                                          )
                                        }
                                      ]
                                      redirects: [
                                        (redir.Redir
                                          op: <Redir_DGreat '>>'>
                                          fd: 16777215
                                          arg_word: 
                                            {
                                              (DQ ($ VSub_DollarName '$output_objdir') (/) 
                                                ($ VSub_DollarName '$my_dlsyms')
                                              )
                                            }
                                        )
                                      ]
                                    )
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (command.Sentence
                                              child: 
                                                (C {(test)} {(-s)} 
                                                  {(DQ ($ VSub_DollarName '$nlist')) (I)}
                                                )
                                              terminator: <Op_Semi ';'>
                                            )
                                          ]
                                          action: [
                                            (command.Simple
                                              words: [
                                                {(echo)}
                                                {
                                                  (DQ ('static void lt_syminit(void)\n') ('{\n') 
                                                    ('  LT_DLSYM_CONST lt_dlsymlist *symbol = lt_') (${ VSub_Name my_prefix) ('_LTX_preloaded_symbols;\n') ('  for (; symbol->name; ++symbol)\n') ('    {')
                                                  )
                                                }
                                              ]
                                              redirects: [
                                                (redir.Redir
                                                  op: <Redir_DGreat '>>'>
                                                  fd: 16777215
                                                  arg_word: 
                                                    {
                                                      (DQ ($ VSub_DollarName '$output_objdir') (/) 
                                                        ($ VSub_DollarName '$my_dlsyms')
                                                      )
                                                    }
                                                )
                                              ]
                                            )
                                            (command.Simple
                                              words: [
                                                {($ VSub_DollarName '$SED')}
                                                {
                                                  (SQ 
                                                    <
's/.*/      if (STREQ (symbol->name, \\"&\\")) symbol->address = (void *) \\&&;/'
                                                    >
                                                  )
                                                }
                                              ]
                                              redirects: [
                                                (redir.Redir
                                                  op: <Redir_Less '<'>
                                                  fd: 16777215
                                                  arg_word: {(DQ ($ VSub_DollarName '$nlist')) (I)}
                                                )
                                                (redir.Redir
                                                  op: <Redir_DGreat '>>'>
                                                  fd: 16777215
                                                  arg_word: 
                                                    {
                                                      (DQ ($ VSub_DollarName '$output_objdir') (/) 
                                                        ($ VSub_DollarName '$my_dlsyms')
                                                      )
                                                    }
                                                )
                                              ]
                                            )
                                            (command.Simple
                                              words: [{(echo)} {(DQ ('    }\n') ('}'))}]
                                              redirects: [
                                                (redir.Redir
                                                  op: <Redir_DGreat '>>'>
                                                  fd: 16777215
                                                  arg_word: 
                                                    {
                                                      (DQ ($ VSub_DollarName '$output_objdir') (/) 
                                                        ($ VSub_DollarName '$my_dlsyms')
                                                      )
                                                    }
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                    (command.Simple
                                      words: [
                                        {(echo)}
                                        {
                                          (DQ ('LT_DLSYM_CONST lt_dlsymlist\n') (lt_) 
                                            (${ VSub_Name my_prefix) ('_LTX_preloaded_symbols[] =\n') ('{ {') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) 
                                            ($ VSub_DollarName '$my_originator') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) (', (void *) 0},')
                                          )
                                        }
                                      ]
                                      redirects: [
                                        (redir.Redir
                                          op: <Redir_DGreat '>>'>
                                          fd: 16777215
                                          arg_word: 
                                            {
                                              (DQ ($ VSub_DollarName '$output_objdir') (/) 
                                                ($ VSub_DollarName '$my_dlsyms')
                                              )
                                            }
                                        )
                                      ]
                                    )
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (command.Sentence
                                              child: 
                                                (C {(test)} {(-s)} 
                                                  {(DQ ($ VSub_DollarName '$nlist')) (I)}
                                                )
                                              terminator: <Op_Semi ';'>
                                            )
                                          ]
                                          action: [
                                            (command.Simple
                                              words: [
                                                {(echo)}
                                                {
                                                  (DQ ('  {') 
                                                    (word_part.EscapedLiteral
                                                      token: <Lit_EscapedChar '\\"'>
                                                    ) ('@INIT@') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) (', (void *) &lt_syminit},')
                                                  )
                                                }
                                              ]
                                              redirects: [
                                                (redir.Redir
                                                  op: <Redir_DGreat '>>'>
                                                  fd: 16777215
                                                  arg_word: 
                                                    {
                                                      (DQ ($ VSub_DollarName '$output_objdir') (/) 
                                                        ($ VSub_DollarName '$my_dlsyms')
                                                      )
                                                    }
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                    (command.Case
                                      to_match: {($ VSub_DollarName '$need_lib_prefix')}
                                      arms: [
                                        (case_arm
                                          pat_list: [{(no)}]
                                          action: [
                                            (command.Simple
                                              words: [
                                                {(eval)}
                                                {
                                                  (DQ 
                                                    ($ VSub_DollarName 
'$global_symbol_to_c_name_address'
                                                    )
                                                  )
                                                }
                                              ]
                                              redirects: [
                                                (redir.Redir
                                                  op: <Redir_Less '<'>
                                                  fd: 16777215
                                                  arg_word: {(DQ ($ VSub_DollarName '$nlist'))}
                                                )
                                                (redir.Redir
                                                  op: <Redir_DGreat '>>'>
                                                  fd: 16777215
                                                  arg_word: 
                                                    {
                                                      (DQ ($ VSub_DollarName '$output_objdir') (/) 
                                                        ($ VSub_DollarName '$my_dlsyms')
                                                      )
                                                    }
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                        (case_arm
                                          pat_list: [{(Lit_Star '*')}]
                                          action: [
                                            (command.Simple
                                              words: [
                                                {(eval)}
                                                {
                                                  (DQ 
                                                    ($ VSub_DollarName 
'$global_symbol_to_c_name_address_lib_prefix'
                                                    )
                                                  )
                                                }
                                              ]
                                              redirects: [
                                                (redir.Redir
                                                  op: <Redir_Less '<'>
                                                  fd: 16777215
                                                  arg_word: {(DQ ($ VSub_DollarName '$nlist'))}
                                                )
                                                (redir.Redir
                                                  op: <Redir_DGreat '>>'>
                                                  fd: 16777215
                                                  arg_word: 
                                                    {
                                                      (DQ ($ VSub_DollarName '$output_objdir') (/) 
                                                        ($ VSub_DollarName '$my_dlsyms')
                                                      )
                                                    }
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                    (command.Simple
                                      words: [
                                        {(echo)}
                                        {
                                          (DQ ('  {0, (void *) 0}\n') ('};\n') ('\n') 
                                            (
'/* This works around a problem in FreeBSD linker */\n'
                                            ) ('#ifdef FREEBSD_WORKAROUND\n') ('static const void *lt_preloaded_setup() {\n') ('  return lt_') 
                                            (${ VSub_Name my_prefix) ('_LTX_preloaded_symbols;\n') ('}\n') ('#endif\n') ('\n') ('#ifdef __cplusplus\n') ('}\n') ('#endif')
                                          )
                                        }
                                      ]
                                      redirects: [
                                        (redir.Redir
                                          op: <Redir_DGreat '>>'>
                                          fd: 16777215
                                          arg_word: 
                                            {
                                              (DQ ($ VSub_DollarName '$output_objdir') (/) 
                                                ($ VSub_DollarName '$my_dlsyms')
                                              )
                                            }
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:pic_flag_for_symtable)
                                  op: Equal
                                  rhs: (word.Empty)
                                )
                              ]
                            )
                            (command.Case
                              to_match: {(DQ ($ VSub_DollarName '$compile_command') (' '))}
                              arms: [
                                (case_arm
                                  pat_list: [{(Lit_Star '*') (DQ (' -static ')) (Lit_Star '*')}]
                                )
                                (case_arm
                                  pat_list: [{(Lit_Star '*')}]
                                  action: [
                                    (command.Case
                                      to_match: {($ VSub_DollarName '$host')}
                                      arms: [
                                        (case_arm
                                          pat_list: [
                                            {(Lit_Star '*') (-) (Lit_Star '*') (-freebsd2.) 
                                              (Lit_Star '*')
                                            }
                                            {(Lit_Star '*') (-) (Lit_Star '*') (-freebsd3.0) 
                                              (Lit_Star '*')
                                            }
                                            {(Lit_Star '*') (-) (Lit_Star '*') (-freebsdelf3.0) 
                                              (Lit_Star '*')
                                            }
                                          ]
                                          action: [
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:pic_flag_for_symtable)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ (' ') ($ VSub_DollarName '$pic_flag') 
                                                        (' -DFREEBSD_WORKAROUND')
                                                      )
                                                    }
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                        (case_arm
                                          pat_list: [
                                            {(Lit_Star '*') (-) (Lit_Star '*') (-hpux) (Lit_Star '*')}
                                          ]
                                          action: [
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:pic_flag_for_symtable)
                                                  op: Equal
                                                  rhs: {(DQ (' ') ($ VSub_DollarName '$pic_flag'))}
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                        (case_arm
                                          pat_list: [{(Lit_Star '*')}]
                                          action: [
                                            (command.AndOr
                                              ops: [Op_DAmp]
                                              children: [
                                                (C {($ VSub_DollarName '$my_pic_p')})
                                                (command.ShAssignment
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: 
                                                        (sh_lhs_expr.Name
                                                          name: pic_flag_for_symtable
                                                        )
                                                      op: Equal
                                                      rhs: {(DQ (' ') ($ VSub_DollarName '$pic_flag'))}
                                                    )
                                                  ]
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:symtab_cflags)
                                  op: Equal
                                  rhs: (word.Empty)
                                )
                              ]
                            )
                            (command.ForEach
                              iter_name: arg
                              iter_words: [{($ VSub_DollarName '$LTCFLAGS')}]
                              do_arg_iter: F
                              body: 
                                (command.DoGroup
                                  children: [
                                    (command.Case
                                      to_match: {($ VSub_DollarName '$arg')}
                                      arms: [
                                        (case_arm
                                          pat_list: [{(-pie)} {(-fpie)} {(-fPIE)}]
                                        )
                                        (case_arm
                                          pat_list: [{(Lit_Star '*')}]
                                          action: [
                                            (C {(func_append)} {(symtab_cflags)} 
                                              {(DQ (' ') ($ VSub_DollarName '$arg'))}
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                  ]
                                )
                            )
                            (C {(func_show_eval)} 
                              {
                                (SQ 
                                  <
'(cd $output_objdir && $LTCC$symtab_cflags -c$no_builtin_flag$pic_flag_for_symtable "$my_dlsyms")'
                                  >
                                )
                              } {(SQ <'exit $?'>)}
                            )
                            (C {(func_show_eval)} 
                              {
                                (SQ 
                                  <
'$RM "$output_objdir/$my_dlsyms" "$nlist" "${nlist}S" "${nlist}T" "${nlist}I"'
                                  >
                                )
                              }
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:symfileobj)
                                  op: Equal
                                  rhs: 
                                    {($ VSub_DollarName '$output_objdir') (/) 
                                      (${ VSub_Name my_outputname) (S.) ($ VSub_DollarName '$objext')
                                    }
                                )
                              ]
                            )
                            (command.Case
                              to_match: {($ VSub_DollarName '$host')}
                              arms: [
                                (case_arm
                                  pat_list: [
                                    {(Lit_Star '*') (cygwin) (Lit_Star '*')}
                                    {(Lit_Star '*') (mingw) (Lit_Star '*')}
                                    {(Lit_Star '*') (cegcc) (Lit_Star '*')}
                                  ]
                                  action: [
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (command.Sentence
                                              child: 
                                                (C {(test)} {(-f)} 
                                                  {
                                                    (DQ ($ VSub_DollarName '$output_objdir') (/) 
                                                      ($ VSub_DollarName '$my_outputname') (.def)
                                                    )
                                                  }
                                                )
                                              terminator: <Op_Semi ';'>
                                            )
                                          ]
                                          action: [
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:compile_command)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (command_sub
                                                        left_token: <Left_Backtick '`'>
                                                        command_list: 
                                                          (command.CommandList
                                                            children: [
                                                              (command.Pipeline
                                                                children: [
                                                                  (C {($ VSub_DollarName '$ECHO')} 
                                                                    {
                                                                      (DQ 
                                                                        ($ VSub_DollarName 
'$compile_command'
                                                                        )
                                                                      )
                                                                    }
                                                                  )
                                                                  (C {($ VSub_DollarName '$SED')} 
                                                                    {
                                                                      (DQ ('s%@SYMFILE@%') 
                                                                        ($ VSub_DollarName 
'$output_objdir'
                                                                        ) (/) ($ VSub_DollarName '$my_outputname') ('.def ') ($ VSub_DollarName '$symfileobj') ('%')
                                                                      )
                                                                    }
                                                                  )
                                                                ]
                                                                negated: F
                                                              )
                                                            ]
                                                          )
                                                      )
                                                    }
                                                )
                                              ]
                                            )
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:finalize_command)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (command_sub
                                                        left_token: <Left_Backtick '`'>
                                                        command_list: 
                                                          (command.CommandList
                                                            children: [
                                                              (command.Pipeline
                                                                children: [
                                                                  (C {($ VSub_DollarName '$ECHO')} 
                                                                    {
                                                                      (DQ 
                                                                        ($ VSub_DollarName 
'$finalize_command'
                                                                        )
                                                                      )
                                                                    }
                                                                  )
                                                                  (C {($ VSub_DollarName '$SED')} 
                                                                    {
                                                                      (DQ ('s%@SYMFILE@%') 
                                                                        ($ VSub_DollarName 
'$output_objdir'
                                                                        ) (/) ($ VSub_DollarName '$my_outputname') ('.def ') ($ VSub_DollarName '$symfileobj') ('%')
                                                                      )
                                                                    }
                                                                  )
                                                                ]
                                                                negated: F
                                                              )
                                                            ]
                                                          )
                                                      )
                                                    }
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                      ]
                                      else_action: [
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:compile_command)
                                              op: Equal
                                              rhs: 
                                                {
                                                  (command_sub
                                                    left_token: <Left_Backtick '`'>
                                                    command_list: 
                                                      (command.CommandList
                                                        children: [
                                                          (command.Pipeline
                                                            children: [
                                                              (C {($ VSub_DollarName '$ECHO')} 
                                                                {
                                                                  (DQ 
                                                                    ($ VSub_DollarName 
'$compile_command'
                                                                    )
                                                                  )
                                                                }
                                                              )
                                                              (C {($ VSub_DollarName '$SED')} 
                                                                {
                                                                  (DQ ('s%@SYMFILE@%') 
                                                                    ($ VSub_DollarName '$symfileobj') ('%')
                                                                  )
                                                                }
                                                              )
                                                            ]
                                                            negated: F
                                                          )
                                                        ]
                                                      )
                                                  )
                                                }
                                            )
                                          ]
                                        )
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:finalize_command)
                                              op: Equal
                                              rhs: 
                                                {
                                                  (command_sub
                                                    left_token: <Left_Backtick '`'>
                                                    command_list: 
                                                      (command.CommandList
                                                        children: [
                                                          (command.Pipeline
                                                            children: [
                                                              (C {($ VSub_DollarName '$ECHO')} 
                                                                {
                                                                  (DQ 
                                                                    ($ VSub_DollarName 
'$finalize_command'
                                                                    )
                                                                  )
                                                                }
                                                              )
                                                              (C {($ VSub_DollarName '$SED')} 
                                                                {
                                                                  (DQ ('s%@SYMFILE@%') 
                                                                    ($ VSub_DollarName '$symfileobj') ('%')
                                                                  )
                                                                }
                                                              )
                                                            ]
                                                            negated: F
                                                          )
                                                        ]
                                                      )
                                                  )
                                                }
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                  ]
                                )
                                (case_arm
                                  pat_list: [{(Lit_Star '*')}]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:compile_command)
                                          op: Equal
                                          rhs: 
                                            {
                                              (command_sub
                                                left_token: <Left_Backtick '`'>
                                                command_list: 
                                                  (command.CommandList
                                                    children: [
                                                      (command.Pipeline
                                                        children: [
                                                          (C {($ VSub_DollarName '$ECHO')} 
                                                            {
                                                              (DQ 
                                                                ($ VSub_DollarName '$compile_command')
                                                              )
                                                            }
                                                          )
                                                          (C {($ VSub_DollarName '$SED')} 
                                                            {
                                                              (DQ ('s%@SYMFILE@%') 
                                                                ($ VSub_DollarName '$symfileobj') ('%')
                                                              )
                                                            }
                                                          )
                                                        ]
                                                        negated: F
                                                      )
                                                    ]
                                                  )
                                              )
                                            }
                                        )
                                      ]
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:finalize_command)
                                          op: Equal
                                          rhs: 
                                            {
                                              (command_sub
                                                left_token: <Left_Backtick '`'>
                                                command_list: 
                                                  (command.CommandList
                                                    children: [
                                                      (command.Pipeline
                                                        children: [
                                                          (C {($ VSub_DollarName '$ECHO')} 
                                                            {
                                                              (DQ 
                                                                ($ VSub_DollarName 
'$finalize_command'
                                                                )
                                                              )
                                                            }
                                                          )
                                                          (C {($ VSub_DollarName '$SED')} 
                                                            {
                                                              (DQ ('s%@SYMFILE@%') 
                                                                ($ VSub_DollarName '$symfileobj') ('%')
                                                              )
                                                            }
                                                          )
                                                        ]
                                                        negated: F
                                                      )
                                                    ]
                                                  )
                                              )
                                            }
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(Lit_Star '*')}]
                          action: [
                            (C {(func_fatal_error)} 
                              {(DQ ("unknown suffix for '") ($ VSub_DollarName '$my_dlsyms') ("'"))}
                            )
                          ]
                        )
                      ]
                    )
                  ]
                )
              ]
              else_action: [
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:compile_command)
                      op: Equal
                      rhs: 
                        {
                          (command_sub
                            left_token: <Left_Backtick '`'>
                            command_list: 
                              (command.CommandList
                                children: [
                                  (command.Pipeline
                                    children: [
                                      (C {($ VSub_DollarName '$ECHO')} 
                                        {(DQ ($ VSub_DollarName '$compile_command'))}
                                      )
                                      (C {($ VSub_DollarName '$SED')} {(DQ ('s% @SYMFILE@%%'))})
                                    ]
                                    negated: F
                                  )
                                ]
                              )
                          )
                        }
                    )
                  ]
                )
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:finalize_command)
                      op: Equal
                      rhs: 
                        {
                          (command_sub
                            left_token: <Left_Backtick '`'>
                            command_list: 
                              (command.CommandList
                                children: [
                                  (command.Pipeline
                                    children: [
                                      (C {($ VSub_DollarName '$ECHO')} 
                                        {(DQ ($ VSub_DollarName '$finalize_command'))}
                                      )
                                      (C {($ VSub_DollarName '$SED')} {(DQ ('s% @SYMFILE@%%'))})
                                    ]
                                    negated: F
                                  )
                                ]
                              )
                          )
                        }
                    )
                  ]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: func_cygming_gnu_implib_p
      body: 
        (command.BraceGroup
          children: [
            (C {($ VSub_DollarName '$debug_cmd')})
            (C {(func_to_tool_file)} {(DQ ($ VSub_Number '$1'))} {(func_convert_file_msys_to_w32)})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:func_cygming_gnu_implib_tmp)
                  op: Equal
                  rhs: 
                    {
                      (command_sub
                        left_token: <Left_Backtick '`'>
                        command_list: 
                          (command.CommandList
                            children: [
                              (command.Pipeline
                                children: [
                                  (C {($ VSub_DollarName '$NM')} 
                                    {(DQ ($ VSub_DollarName '$func_to_tool_file_result'))}
                                  )
                                  (C {(eval)} {(DQ ($ VSub_DollarName '$global_symbol_pipe'))})
                                  (C {($ VSub_DollarName '$EGREP')} 
                                    {
                                      (SQ 
                                        <
' (_head_[A-Za-z0-9_]+_[ad]l*|[A-Za-z0-9_]+_[ad]l*_iname)$'
                                        >
                                      )
                                    }
                                  )
                                ]
                                negated: F
                              )
                            ]
                          )
                      )
                    }
                )
              ]
            )
            (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$func_cygming_gnu_implib_tmp'))})
          ]
        )
    )
    (command.ShFunction
      name: func_cygming_ms_implib_p
      body: 
        (command.BraceGroup
          children: [
            (C {($ VSub_DollarName '$debug_cmd')})
            (C {(func_to_tool_file)} {(DQ ($ VSub_Number '$1'))} {(func_convert_file_msys_to_w32)})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:func_cygming_ms_implib_tmp)
                  op: Equal
                  rhs: 
                    {
                      (command_sub
                        left_token: <Left_Backtick '`'>
                        command_list: 
                          (command.CommandList
                            children: [
                              (command.Pipeline
                                children: [
                                  (C {($ VSub_DollarName '$NM')} 
                                    {(DQ ($ VSub_DollarName '$func_to_tool_file_result'))}
                                  )
                                  (C {(eval)} {(DQ ($ VSub_DollarName '$global_symbol_pipe'))})
                                  (C {($ VSub_DollarName '$GREP')} {(SQ <_NULL_IMPORT_DESCRIPTOR>)})
                                ]
                                negated: F
                              )
                            ]
                          )
                      )
                    }
                )
              ]
            )
            (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$func_cygming_ms_implib_tmp'))})
          ]
        )
    )
    (command.ShFunction
      name: func_win32_libid
      body: 
        (command.BraceGroup
          children: [
            (C {($ VSub_DollarName '$debug_cmd')})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:win32_libid_type)
                  op: Equal
                  rhs: {(unknown)}
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:win32_fileres)
                  op: Equal
                  rhs: 
                    {
                      (command_sub
                        left_token: <Left_Backtick '`'>
                        command_list: 
                          (command.CommandList
                            children: [
                              (command.Simple
                                words: [{(file)} {(-L)} {($ VSub_Number '$1')}]
                                redirects: [
                                  (redir.Redir
                                    op: <Redir_Great '2>'>
                                    fd: 2
                                    arg_word: {(/dev/null)}
                                  )
                                ]
                              )
                            ]
                          )
                      )
                    }
                )
              ]
            )
            (command.Case
              to_match: {($ VSub_DollarName '$win32_fileres')}
              arms: [
                (case_arm
                  pat_list: [
                    {(Lit_Star '*') (ar) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\ '>) 
                      (archive) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\ '>) (import) 
                      (word_part.EscapedLiteral token:<Lit_EscapedChar '\\ '>) (library) (Lit_Star '*')
                    }
                  ]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:win32_libid_type)
                          op: Equal
                          rhs: {(DQ ('x86 archive import'))}
                        )
                      ]
                    )
                  ]
                )
                (case_arm
                  pat_list: [
                    {(Lit_Star '*') (ar) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\ '>) 
                      (archive) (Lit_Star '*')
                    }
                  ]
                  action: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: 
                                (command.Pipeline
                                  children: [
                                    (C {(eval)} {($ VSub_DollarName '$OBJDUMP')} {(-f)} 
                                      {($ VSub_Number '$1')}
                                    )
                                    (command.Simple
                                      words: [{($ VSub_DollarName '$SED')} {(-e)} {(SQ <10q>)}]
                                      redirects: [
                                        (redir.Redir
                                          op: <Redir_Great '2>'>
                                          fd: 2
                                          arg_word: {(/dev/null)}
                                        )
                                      ]
                                    )
                                    (command.Simple
                                      words: [
                                        {($ VSub_DollarName '$EGREP')}
                                        {
                                          (SQ 
                                            <
'file format (pei*-i386(.*architecture: i386)?|pe-arm-wince|pe-x86-64)'
                                            >
                                          )
                                        }
                                      ]
                                      redirects: [
                                        (redir.Redir
                                          op: <Redir_Great '>'>
                                          fd: 16777215
                                          arg_word: {(/dev/null)}
                                        )
                                      ]
                                    )
                                  ]
                                  negated: F
                                )
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [
                            (command.Case
                              to_match: {($ VSub_DollarName '$nm_interface')}
                              arms: [
                                (case_arm
                                  pat_list: [{(DQ ('MS dumpbin'))}]
                                  action: [
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (command.AndOr
                                              ops: [Op_DPipe]
                                              children: [
                                                (C {(func_cygming_ms_implib_p)} 
                                                  {(DQ ($ VSub_Number '$1'))}
                                                )
                                                (C {(func_cygming_gnu_implib_p)} 
                                                  {(DQ ($ VSub_Number '$1'))}
                                                )
                                              ]
                                            )
                                          ]
                                          action: [
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:win32_nmres)
                                                  op: Equal
                                                  rhs: {(import)}
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                      ]
                                      else_action: [
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:win32_nmres)
                                              op: Equal
                                              rhs: (word.Empty)
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                  ]
                                )
                                (case_arm
                                  pat_list: [{(Lit_Star '*')}]
                                  action: [
                                    (C {(func_to_tool_file)} {(DQ ($ VSub_Number '$1'))} 
                                      {(func_convert_file_msys_to_w32)}
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:win32_nmres)
                                          op: Equal
                                          rhs: 
                                            {
                                              (command_sub
                                                left_token: <Left_Backtick '`'>
                                                command_list: 
                                                  (command.CommandList
                                                    children: [
                                                      (command.Pipeline
                                                        children: [
                                                          (C {(eval)} {($ VSub_DollarName '$NM')} {(-f)} 
                                                            {(posix)} {(-A)} {(DQ ($ VSub_DollarName '$func_to_tool_file_result'))}
                                                          )
                                                          (C {($ VSub_DollarName '$SED')} {(-n)} {(-e)} 
                                                            {
                                                              (SQ <'\n'> <'\t    1,100{\n'> 
                                                                <'\t\t/ I /{\n'> <'\t\t    s|.*|import|\n'> <'\t\t    p\n'> <'\t\t    q\n'> <'\t\t}\n'> <'\t    }'>
                                                              )
                                                            }
                                                          )
                                                        ]
                                                        negated: F
                                                      )
                                                    ]
                                                  )
                                              )
                                            }
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.Case
                              to_match: {($ VSub_DollarName '$win32_nmres')}
                              arms: [
                                (case_arm
                                  pat_list: [{(import) (Lit_Star '*')}]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:win32_libid_type)
                                          op: Equal
                                          rhs: {(DQ ('x86 archive import'))}
                                        )
                                      ]
                                    )
                                  ]
                                )
                                (case_arm
                                  pat_list: [{(Lit_Star '*')}]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:win32_libid_type)
                                          op: Equal
                                          rhs: {(DQ ('x86 archive static'))}
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                            )
                          ]
                        )
                      ]
                    )
                  ]
                )
                (case_arm
                  pat_list: [{(Lit_Star '*') (DLL) (Lit_Star '*')}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:win32_libid_type)
                          op: Equal
                          rhs: {(DQ ('x86 DLL'))}
                        )
                      ]
                    )
                  ]
                )
                (case_arm
                  pat_list: [{(Lit_Star '*') (executable) (Lit_Star '*')}]
                  action: [
                    (command.Case
                      to_match: {($ VSub_DollarName '$win32_fileres')}
                      arms: [
                        (case_arm
                          pat_list: [
                            {(Lit_Star '*') (MS) 
                              (word_part.EscapedLiteral
                                token: <Lit_EscapedChar '\\ '>
                              ) (Windows) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\ '>) (PE) 
                              (word_part.EscapedLiteral
                                token: <Lit_EscapedChar '\\ '>
                              ) (Intel) (Lit_Star '*')
                            }
                          ]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:win32_libid_type)
                                  op: Equal
                                  rhs: {(DQ ('x86 DLL'))}
                                )
                              ]
                            )
                          ]
                        )
                      ]
                    )
                  ]
                )
              ]
            )
            (C {($ VSub_DollarName '$ECHO')} {(DQ ($ VSub_DollarName '$win32_libid_type'))})
          ]
        )
    )
    (command.ShFunction
      name: func_cygming_dll_for_implib
      body: 
        (command.BraceGroup
          children: [
            (C {($ VSub_DollarName '$debug_cmd')})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:sharedlib_from_linklib_result)
                  op: Equal
                  rhs: 
                    {
                      (command_sub
                        left_token: <Left_Backtick '`'>
                        command_list: 
                          (command.CommandList
                            children: [
                              (C {($ VSub_DollarName '$DLLTOOL')} {(--identify-strict)} {(--identify)} 
                                {(DQ ($ VSub_Number '$1'))}
                              )
                            ]
                          )
                      )
                    }
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: func_cygming_dll_for_implib_fallback_core
      body: 
        (command.BraceGroup
          children: [
            (C {($ VSub_DollarName '$debug_cmd')})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:match_literal)
                  op: Equal
                  rhs: 
                    {
                      (command_sub
                        left_token: <Left_Backtick '`'>
                        command_list: 
                          (command.CommandList
                            children: [
                              (command.Pipeline
                                children: [
                                  (C {($ VSub_DollarName '$ECHO')} {(DQ ($ VSub_Number '$1'))})
                                  (C {($ VSub_DollarName '$SED')} 
                                    {(DQ ($ VSub_DollarName '$sed_make_literal_regex'))}
                                  )
                                ]
                                negated: F
                              )
                            ]
                          )
                      )
                    }
                )
              ]
            )
            (command.Pipeline
              children: [
                (command.Simple
                  words: [
                    {($ VSub_DollarName '$OBJDUMP')}
                    {(-s)}
                    {(--section)}
                    {(DQ ($ VSub_Number '$1'))}
                    {(DQ ($ VSub_Number '$2'))}
                  ]
                  redirects: [(redir.Redir op:<Redir_Great '2>'> fd:2 arg_word:{(/dev/null)})]
                )
                (C {($ VSub_DollarName '$SED')} 
                  {(SQ <'/^Contents of section '>) (DQ ($ VSub_DollarName '$match_literal')) 
                    (SQ <':/{\n'> 
                      <'      # Place marker at beginning of archive member dllname section\n'> <'      s/.*/====MARK====/\n'> <'      p\n'> <'      d\n'> <'    }\n'> 
                      <'    # These lines can sometimes be longer than 43 characters, but\n'> <'    # are always uninteresting\n'> <'    /:[\t ]*file format pe[i]\\{,1\\}-/d\n'> 
                      <'    /^In archive [^:]*:/d\n'> <'    # Ensure marker is printed\n'> <'    /^====MARK====/p\n'> 
                      <'    # Remove all lines with less than 43 characters\n'> <'    /^.\\{43\\}/!d\n'> <'    # From remaining lines, remove first 43 characters\n'> 
                      <'    s/^.\\{43\\}//'>
                    )
                  }
                )
                (C {($ VSub_DollarName '$SED')} {(-n)} 
                  {
                    (SQ <'\n'> 
                      <'      # Join marker and all lines until next marker into a single line\n'> <'      /^====MARK====/ b para\n'> <'      H\n'> <'      $ b para\n'> <'      b\n'> <'      :para\n'> 
                      <'      x\n'> <'      s/\\n//g\n'> <'      # Remove the marker\n'> <'      s/^====MARK====//\n'> 
                      <'      # Remove trailing dots and whitespace\n'> <'      s/[\\. \\t]*$//\n'> <'      # Print\n'> <'      /./p'>
                    )
                  }
                )
                (C {($ VSub_DollarName '$SED')} {(-e)} {(SQ <'/^\\./d;/^.\\./d;q'>)})
              ]
              negated: F
            )
          ]
        )
    )
    (command.ShFunction
      name: func_cygming_dll_for_implib_fallback
      body: 
        (command.BraceGroup
          children: [
            (C {($ VSub_DollarName '$debug_cmd')})
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: (C {(func_cygming_gnu_implib_p)} {(DQ ($ VSub_Number '$1'))})
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:sharedlib_from_linklib_result)
                          op: Equal
                          rhs: 
                            {
                              (command_sub
                                left_token: <Left_Backtick '`'>
                                command_list: 
                                  (command.CommandList
                                    children: [
                                      (C {(func_cygming_dll_for_implib_fallback_core)} 
                                        {(SQ <'.idata$7'>)} {(DQ ($ VSub_Number '$1'))}
                                      )
                                    ]
                                  )
                              )
                            }
                        )
                      ]
                    )
                  ]
                )
                (if_arm
                  cond: [
                    (command.Sentence
                      child: (C {(func_cygming_ms_implib_p)} {(DQ ($ VSub_Number '$1'))})
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:sharedlib_from_linklib_result)
                          op: Equal
                          rhs: 
                            {
                              (command_sub
                                left_token: <Left_Backtick '`'>
                                command_list: 
                                  (command.CommandList
                                    children: [
                                      (C {(func_cygming_dll_for_implib_fallback_core)} 
                                        {(SQ <'.idata$6'>)} {(DQ ($ VSub_Number '$1'))}
                                      )
                                    ]
                                  )
                              )
                            }
                        )
                      ]
                    )
                  ]
                )
              ]
              else_action: [
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:sharedlib_from_linklib_result)
                      op: Equal
                      rhs: (word.Empty)
                    )
                  ]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: func_extract_an_archive
      body: 
        (command.BraceGroup
          children: [
            (C {($ VSub_DollarName '$debug_cmd')})
            (command.Sentence
              child: 
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:f_ex_an_ar_dir)
                      op: Equal
                      rhs: {($ VSub_Number '$1')}
                    )
                  ]
                )
              terminator: <Op_Semi ';'>
            )
            (C {(shift)})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:f_ex_an_ar_oldlib)
                  op: Equal
                  rhs: {($ VSub_Number '$1')}
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: 
                        (C {(test)} {(yes)} {(Lit_Equals '=')} 
                          {(DQ ($ VSub_DollarName '$lock_old_archive_extraction'))}
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:lockfile)
                          op: Equal
                          rhs: {($ VSub_DollarName '$f_ex_an_ar_oldlib') (.lock)}
                        )
                      ]
                    )
                    (command.WhileUntil
                      keyword: <KW_Until until>
                      cond: [
                        (command.Sentence
                          child: 
                            (command.AndOr
                              ops: [Op_DPipe]
                              children: [
                                (C {($ VSub_DollarName '$opt_dry_run')})
                                (command.Simple
                                  words: [
                                    {(ln)}
                                    {(DQ ($ VSub_DollarName '$progpath'))}
                                    {(DQ ($ VSub_DollarName '$lockfile'))}
                                  ]
                                  redirects: [
                                    (redir.Redir
                                      op: <Redir_Great '2>'>
                                      fd: 2
                                      arg_word: {(/dev/null)}
                                    )
                                  ]
                                )
                              ]
                            )
                          terminator: <Op_Semi ';'>
                        )
                      ]
                      body: 
                        (command.DoGroup
                          children: [
                            (C {(func_echo)} 
                              {
                                (DQ ('Waiting for ') ($ VSub_DollarName '$lockfile') (' to be removed'))
                              }
                            )
                            (C {(sleep)} {(2)})
                          ]
                        )
                    )
                  ]
                )
              ]
            )
            (C {(func_show_eval)} 
              {
                (DQ ('(cd ') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) 
                  ('f_ex_an_ar_dir && ') ($ VSub_DollarName '$AR') (' x ') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) (f_ex_an_ar_oldlib) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) (')')
                )
              } {(SQ <'stat=$?; rm -f "$lockfile"; exit $stat'>)}
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: 
                        (C {(test)} {(yes)} {(Lit_Equals '=')} 
                          {(DQ ($ VSub_DollarName '$lock_old_archive_extraction'))}
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (command.AndOr
                      ops: [Op_DPipe]
                      children: [
                        (C {($ VSub_DollarName '$opt_dry_run')})
                        (C {(rm)} {(-f)} {(DQ ($ VSub_DollarName '$lockfile'))})
                      ]
                    )
                  ]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: 
                        (command.Subshell
                          command_list: 
                            (command.CommandList
                              children: [
                                (command.Pipeline
                                  children: [
                                    (C {($ VSub_DollarName '$AR')} {(t)} 
                                      {(DQ ($ VSub_DollarName '$f_ex_an_ar_oldlib'))}
                                    )
                                    (C {(sort)})
                                    (command.Simple
                                      words: [{(sort)} {(-uc)}]
                                      redirects: [
                                        (redir.Redir
                                          op: <Redir_Great '>'>
                                          fd: 16777215
                                          arg_word: {(/dev/null)}
                                        )
                                        (redir.Redir
                                          op: <Redir_GreatAnd '2>&'>
                                          fd: 2
                                          arg_word: {(1)}
                                        )
                                      ]
                                    )
                                  ]
                                  negated: F
                                )
                              ]
                            )
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [(C {(Lit_Other ':')})]
                )
              ]
              else_action: [
                (C {(func_fatal_error)} 
                  {
                    (DQ ('object name conflicts in archive: ') ($ VSub_DollarName '$f_ex_an_ar_dir') 
                      (/) ($ VSub_DollarName '$f_ex_an_ar_oldlib')
                    )
                  }
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: func_extract_archives
      body: 
        (command.BraceGroup
          children: [
            (C {($ VSub_DollarName '$debug_cmd')})
            (command.Sentence
              child: 
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:my_gentop)
                      op: Equal
                      rhs: {($ VSub_Number '$1')}
                    )
                  ]
                )
              terminator: <Op_Semi ';'>
            )
            (C {(shift)})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:my_oldlibs)
                  op: Equal
                  rhs: 
                    {
                      (braced_var_sub
                        token: <VSub_Number 1>
                        suffix_op: (suffix_op.Unary op_id:VTest_Plus arg_word:{(DQ ($ VSub_At '$@'))})
                      )
                    }
                )
              ]
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:my_oldobjs) op:Equal rhs:(word.Empty))]
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:my_xlib) op:Equal rhs:(word.Empty))]
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:my_xabs) op:Equal rhs:(word.Empty))]
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:my_xdir) op:Equal rhs:(word.Empty))]
            )
            (command.ForEach
              iter_name: my_xlib
              iter_words: [{($ VSub_DollarName '$my_oldlibs')}]
              do_arg_iter: F
              body: 
                (command.DoGroup
                  children: [
                    (command.Case
                      to_match: {($ VSub_DollarName '$my_xlib')}
                      arms: [
                        (case_arm
                          pat_list: [
                            {(Lit_LBracket '[') 
                              (word_part.EscapedLiteral
                                token: <Lit_EscapedChar '\\\\'>
                              ) (/) (Lit_RBracket ']') (Lit_Star '*')
                            }
                            {(Lit_LBracket '[') (A-Za-z) (Lit_RBracket ']') (Lit_Other ':') 
                              (Lit_LBracket '[') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\\\'>) (/) (Lit_RBracket ']') (Lit_Star '*')
                            }
                          ]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:my_xabs)
                                  op: Equal
                                  rhs: {($ VSub_DollarName '$my_xlib')}
                                )
                              ]
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(Lit_Star '*')}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:my_xabs)
                                  op: Equal
                                  rhs: 
                                    {
                                      (command_sub
                                        left_token: <Left_Backtick '`'>
                                        command_list: (command.CommandList children:[(C {(pwd)})])
                                      ) (DQ (/) ($ VSub_DollarName '$my_xlib'))
                                    }
                                )
                              ]
                            )
                          ]
                        )
                      ]
                    )
                    (C {(func_basename)} {(DQ ($ VSub_DollarName '$my_xlib'))})
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:my_xlib)
                          op: Equal
                          rhs: {($ VSub_DollarName '$func_basename_result')}
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:my_xlib_u)
                          op: Equal
                          rhs: {($ VSub_DollarName '$my_xlib')}
                        )
                      ]
                    )
                    (command.WhileUntil
                      keyword: <KW_While while>
                      cond: [(command.Sentence child:(C {(Lit_Other ':')}) terminator:<Op_Semi ';'>)]
                      body: 
                        (command.DoGroup
                          children: [
                            (command.Case
                              to_match: {(DQ (' ') ($ VSub_DollarName '$extracted_archives') (' '))}
                              arms: [
                                (case_arm
                                  pat_list: [
                                    {(Lit_Star '*') (DQ (' ') ($ VSub_DollarName '$my_xlib_u') (' ')) 
                                      (Lit_Star '*')
                                    }
                                  ]
                                  action: [
                                    (C {(func_arith)} {($ VSub_DollarName '$extracted_serial')} 
                                      {(Lit_Other '+')} {(1)}
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:extracted_serial)
                                          op: Equal
                                          rhs: {($ VSub_DollarName '$func_arith_result')}
                                        )
                                      ]
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:my_xlib_u)
                                          op: Equal
                                          rhs: 
                                            {(lt) ($ VSub_DollarName '$extracted_serial') (-) 
                                              ($ VSub_DollarName '$my_xlib')
                                            }
                                        )
                                      ]
                                    )
                                  ]
                                )
                                (case_arm
                                  pat_list: [{(Lit_Star '*')}]
                                  action: [(command.ControlFlow token:<ControlFlow_Break break>)]
                                )
                              ]
                            )
                          ]
                        )
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:extracted_archives)
                          op: Equal
                          rhs: 
                            {
                              (DQ ($ VSub_DollarName '$extracted_archives') (' ') 
                                ($ VSub_DollarName '$my_xlib_u')
                              )
                            }
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:my_xdir)
                          op: Equal
                          rhs: {($ VSub_DollarName '$my_gentop') (/) ($ VSub_DollarName '$my_xlib_u')}
                        )
                      ]
                    )
                    (C {(func_mkdir_p)} {(DQ ($ VSub_DollarName '$my_xdir'))})
                    (command.Case
                      to_match: {($ VSub_DollarName '$host')}
                      arms: [
                        (case_arm
                          pat_list: [{(Lit_Star '*') (-darwin) (Lit_Star '*')}]
                          action: [
                            (C {(func_verbose)} {(DQ ('Extracting ') ($ VSub_DollarName '$my_xabs'))})
                            (command.AndOr
                              ops: [Op_DPipe]
                              children: [
                                (C {($ VSub_DollarName '$opt_dry_run')})
                                (command.BraceGroup
                                  children: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:darwin_orig_dir)
                                          op: Equal
                                          rhs: 
                                            {
                                              (command_sub
                                                left_token: <Left_Backtick '`'>
                                                command_list: 
                                                  (command.CommandList
                                                    children: [(C {(pwd)})]
                                                  )
                                              )
                                            }
                                        )
                                      ]
                                    )
                                    (command.AndOr
                                      ops: [Op_DPipe]
                                      children: [
                                        (C {(cd)} {($ VSub_DollarName '$my_xdir')})
                                        (command.ControlFlow
                                          token: <ControlFlow_Exit exit>
                                          arg_word: {($ VSub_QMark '$?')}
                                        )
                                      ]
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:darwin_archive)
                                          op: Equal
                                          rhs: {($ VSub_DollarName '$my_xabs')}
                                        )
                                      ]
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:darwin_curdir)
                                          op: Equal
                                          rhs: 
                                            {
                                              (command_sub
                                                left_token: <Left_Backtick '`'>
                                                command_list: 
                                                  (command.CommandList
                                                    children: [(C {(pwd)})]
                                                  )
                                              )
                                            }
                                        )
                                      ]
                                    )
                                    (C {(func_basename)} {(DQ ($ VSub_DollarName '$darwin_archive'))})
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:darwin_base_archive)
                                          op: Equal
                                          rhs: {($ VSub_DollarName '$func_basename_result')}
                                        )
                                      ]
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:darwin_arches)
                                          op: Equal
                                          rhs: 
                                            {
                                              (command_sub
                                                left_token: <Left_Backtick '`'>
                                                command_list: 
                                                  (command.CommandList
                                                    children: [
                                                      (command.AndOr
                                                        ops: [Op_DPipe]
                                                        children: [
                                                          (command.Pipeline
                                                            children: [
                                                              (command.Simple
                                                                words: [
                                                                  {($ VSub_DollarName '$LIPO')}
                                                                  {(-info)}
                                                                  {
                                                                    (DQ 
                                                                      ($ VSub_DollarName 
'$darwin_archive'
                                                                      )
                                                                    )
                                                                  }
                                                                ]
                                                                redirects: [
                                                                  (redir.Redir
                                                                    op: <Redir_Great '2>'>
                                                                    fd: 2
                                                                    arg_word: {(/dev/null)}
                                                                  )
                                                                ]
                                                              )
                                                              (command.Simple
                                                                words: [
                                                                  {($ VSub_DollarName '$GREP')}
                                                                  {(Architectures)}
                                                                ]
                                                                redirects: [
                                                                  (redir.Redir
                                                                    op: <Redir_Great '2>'>
                                                                    fd: 2
                                                                    arg_word: {(/dev/null)}
                                                                  )
                                                                ]
                                                              )
                                                            ]
                                                            negated: F
                                                          )
                                                          (C {(true)})
                                                        ]
                                                      )
                                                    ]
                                                  )
                                              )
                                            }
                                        )
                                      ]
                                    )
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (command.Sentence
                                              child: 
                                                (C {(test)} {(-n)} 
                                                  {(DQ ($ VSub_DollarName '$darwin_arches'))}
                                                )
                                              terminator: <Op_Semi ';'>
                                            )
                                          ]
                                          action: [
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:darwin_arches)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (command_sub
                                                        left_token: <Left_Backtick '`'>
                                                        command_list: 
                                                          (command.CommandList
                                                            children: [
                                                              (command.Pipeline
                                                                children: [
                                                                  (C {($ VSub_DollarName '$ECHO')} 
                                                                    {
                                                                      (DQ 
                                                                        ($ VSub_DollarName 
'$darwin_arches'
                                                                        )
                                                                      )
                                                                    }
                                                                  )
                                                                  (C {($ VSub_DollarName '$SED')} 
                                                                    {(-e)} {(SQ <'s/.*are://'>)}
                                                                  )
                                                                ]
                                                                negated: F
                                                              )
                                                            ]
                                                          )
                                                      )
                                                    }
                                                )
                                              ]
                                            )
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:darwin_arch)
                                                  op: Equal
                                                  rhs: (word.Empty)
                                                )
                                              ]
                                            )
                                            (C {(func_verbose)} 
                                              {
                                                (DQ ($ VSub_DollarName '$darwin_base_archive') 
                                                  (' has multiple architectures ') ($ VSub_DollarName '$darwin_arches')
                                                )
                                              }
                                            )
                                            (command.ForEach
                                              iter_name: darwin_arch
                                              iter_words: [{($ VSub_DollarName '$darwin_arches')}]
                                              do_arg_iter: F
                                              body: 
                                                (command.DoGroup
                                                  children: [
                                                    (C {(func_mkdir_p)} 
                                                      {
                                                        (DQ (unfat-) ($ VSub_Dollar '$$') (/) 
                                                          ($ VSub_DollarName '$darwin_base_archive') (-) ($ VSub_DollarName '$darwin_arch')
                                                        )
                                                      }
                                                    )
                                                    (C {($ VSub_DollarName '$LIPO')} {(-thin)} 
                                                      {($ VSub_DollarName '$darwin_arch')} {(-output)} 
                                                      {
                                                        (DQ (unfat-) ($ VSub_Dollar '$$') (/) 
                                                          ($ VSub_DollarName '$darwin_base_archive') (-) ($ VSub_DollarName '$darwin_arch') (/) ($ VSub_DollarName '$darwin_base_archive')
                                                        )
                                                      } {(DQ ($ VSub_DollarName '$darwin_archive'))}
                                                    )
                                                    (C {(cd)} 
                                                      {
                                                        (DQ (unfat-) ($ VSub_Dollar '$$') (/) 
                                                          ($ VSub_DollarName '$darwin_base_archive') (-) ($ VSub_DollarName '$darwin_arch')
                                                        )
                                                      }
                                                    )
                                                    (C {(func_extract_an_archive)} 
                                                      {
                                                        (DQ 
                                                          (command_sub
                                                            left_token: <Left_Backtick '`'>
                                                            command_list: 
                                                              (command.CommandList
                                                                children: [(C {(pwd)})]
                                                              )
                                                          )
                                                        )
                                                      } {(DQ ($ VSub_DollarName '$darwin_base_archive'))}
                                                    )
                                                    (C {(cd)} 
                                                      {(DQ ($ VSub_DollarName '$darwin_curdir'))}
                                                    )
                                                    (C {($ VSub_DollarName '$RM')} 
                                                      {
                                                        (DQ (unfat-) ($ VSub_Dollar '$$') (/) 
                                                          ($ VSub_DollarName '$darwin_base_archive') (-) ($ VSub_DollarName '$darwin_arch') (/) ($ VSub_DollarName '$darwin_base_archive')
                                                        )
                                                      }
                                                    )
                                                  ]
                                                )
                                            )
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:darwin_filelist)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (command_sub
                                                        left_token: <Left_Backtick '`'>
                                                        command_list: 
                                                          (command.CommandList
                                                            children: [
                                                              (command.Pipeline
                                                                children: [
                                                                  (C {(find)} 
                                                                    {(unfat-) ($ VSub_Dollar '$$')} {(-type)} {(f)} {(-name)} {(word_part.EscapedLiteral token:<Lit_EscapedChar '\\*'>) (.o)} {(-print)} {(-o)} 
                                                                    {(-name)} {(word_part.EscapedLiteral token:<Lit_EscapedChar '\\*'>) (.lo)} {(-print)}
                                                                  )
                                                                  (C {($ VSub_DollarName '$SED')} 
                                                                    {(-e)} {(DQ ($ VSub_DollarName '$sed_basename'))}
                                                                  )
                                                                  (C {(sort)} {(-u)})
                                                                ]
                                                                negated: F
                                                              )
                                                            ]
                                                          )
                                                      )
                                                    }
                                                )
                                              ]
                                            )
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:darwin_file)
                                                  op: Equal
                                                  rhs: (word.Empty)
                                                )
                                              ]
                                            )
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:darwin_files)
                                                  op: Equal
                                                  rhs: (word.Empty)
                                                )
                                              ]
                                            )
                                            (command.ForEach
                                              iter_name: darwin_file
                                              iter_words: [{($ VSub_DollarName '$darwin_filelist')}]
                                              do_arg_iter: F
                                              body: 
                                                (command.DoGroup
                                                  children: [
                                                    (command.ShAssignment
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (sh_lhs_expr.Name name:darwin_files)
                                                          op: Equal
                                                          rhs: 
                                                            {
                                                              (command_sub
                                                                left_token: <Left_Backtick '`'>
                                                                command_list: 
                                                                  (command.CommandList
                                                                    children: [
                                                                      (command.Pipeline
                                                                        children: [
                                                                          (C {(find)} 
                                                                            {(unfat-) 
                                                                              ($ VSub_Dollar '$$')
                                                                            } {(-name)} {($ VSub_DollarName '$darwin_file')} {(-print)}
                                                                          )
                                                                          (C {(sort)})
                                                                          (C 
                                                                            {
                                                                              ($ VSub_DollarName 
'$NL2SP'
                                                                              )
                                                                            }
                                                                          )
                                                                        ]
                                                                        negated: F
                                                                      )
                                                                    ]
                                                                  )
                                                              )
                                                            }
                                                        )
                                                      ]
                                                    )
                                                    (C {($ VSub_DollarName '$LIPO')} {(-create)} 
                                                      {(-output)} {(DQ ($ VSub_DollarName '$darwin_file'))} {($ VSub_DollarName '$darwin_files')}
                                                    )
                                                  ]
                                                )
                                            )
                                            (C {($ VSub_DollarName '$RM')} {(-rf)} 
                                              {(unfat-) ($ VSub_Dollar '$$')}
                                            )
                                            (C {(cd)} {(DQ ($ VSub_DollarName '$darwin_orig_dir'))})
                                          ]
                                        )
                                      ]
                                      else_action: [
                                        (C {(cd)} {($ VSub_DollarName '$darwin_orig_dir')})
                                        (C {(func_extract_an_archive)} 
                                          {(DQ ($ VSub_DollarName '$my_xdir'))} {(DQ ($ VSub_DollarName '$my_xabs'))}
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(Lit_Star '*')}]
                          action: [
                            (C {(func_extract_an_archive)} {(DQ ($ VSub_DollarName '$my_xdir'))} 
                              {(DQ ($ VSub_DollarName '$my_xabs'))}
                            )
                          ]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:my_oldobjs)
                          op: Equal
                          rhs: 
                            {(DQ ($ VSub_DollarName '$my_oldobjs') (' ')) 
                              (command_sub
                                left_token: <Left_Backtick '`'>
                                command_list: 
                                  (command.CommandList
                                    children: [
                                      (command.Pipeline
                                        children: [
                                          (C {(find)} {($ VSub_DollarName '$my_xdir')} {(-name)} 
                                            {(word_part.EscapedLiteral token:<Lit_EscapedChar '\\*'>) 
                                              (.) ($ VSub_DollarName '$objext')
                                            } {(-print)} {(-o)} {(-name)} {(word_part.EscapedLiteral token:<Lit_EscapedChar '\\*'>) (.lo)} {(-print)}
                                          )
                                          (C {(sort)})
                                          (C {($ VSub_DollarName '$NL2SP')})
                                        ]
                                        negated: F
                                      )
                                    ]
                                  )
                              )
                            }
                        )
                      ]
                    )
                  ]
                )
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:func_extract_archives_result)
                  op: Equal
                  rhs: {($ VSub_DollarName '$my_oldobjs')}
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: func_emit_wrapper
      body: 
        (command.BraceGroup
          children: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:func_emit_wrapper_arg1)
                  op: Equal
                  rhs: 
                    {
                      (braced_var_sub
                        token: <VSub_Number 1>
                        suffix_op: (suffix_op.Unary op_id:VTest_Hyphen arg_word:{(no)})
                      )
                    }
                )
              ]
            )
            (C {($ VSub_DollarName '$ECHO')} 
              {
                (DQ ('#! ') ($ VSub_DollarName '$SHELL') ('\n') ('\n') ('# ') 
                  ($ VSub_DollarName '$output') (' - temporary wrapper script for ') ($ VSub_DollarName '$objdir') (/) ($ VSub_DollarName '$outputname') 
                  ('\n') ('# Generated by ') ($ VSub_DollarName '$PROGRAM') (' (GNU ') ($ VSub_DollarName '$PACKAGE') (') ') 
                  ($ VSub_DollarName '$VERSION') ('\n') ('#\n') ('# The ') ($ VSub_DollarName '$output') 
                  (' program cannot be directly executed until all the libtool\n') ('# libraries that it depends on are installed.\n') ('#\n') 
                  ('# This wrapper script should never be moved out of the build directory.\n') ('# If it is, it will not operate correctly.\n') ('\n') 
                  ('# Sed substitution that helps us do robust quoting.  It backslashifies\n') ('# metacharacters that are still active within double-quoted strings.\n') ("sed_quote_subst='") 
                  ($ VSub_DollarName '$sed_quote_subst') ("'\n") ('\n') ('# Be Bourne compatible\n') ('if test -n ') 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) ('{ZSH_VERSION+set}') 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) (' && (emulate sh) >/dev/null 2>&1; then\n') ('  emulate sh\n') ('  NULLCMD=:\n') 
                  ('  # Zsh 3.x and 4.x performs word splitting on ') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) ('{1+') 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) ('@') 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) ('}, which\n') ('  # is contrary to our usage.  Disable this feature.\n') ("  alias -g '") 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) ('{1+') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) ('@') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) ("}'='") 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) ('@') 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) ("'\n") ('  setopt NO_GLOB_SUBST\n') ('else\n') ('  case ') 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\`'>) ('(set -o) 2>/dev/null') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\`'>) 
                  (' in *posix*) set -o posix;; esac\n') ('fi\n') ('BIN_SH=xpg4; export BIN_SH # for Tru64\n') ('DUALCASE=1; export DUALCASE # for MKS sh\n') 
                  ('\n') ('# The HP-UX ksh and POSIX shell print the target directory to stdout\n') ('# if CDPATH is set.\n') 
                  ('(unset CDPATH) >/dev/null 2>&1 && unset CDPATH\n') ('\n') ('relink_command=') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) 
                  ($ VSub_DollarName '$relink_command') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) ('\n') ('\n') 
                  ('# This environment variable determines our operation mode.\n') ('if test ') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) (libtool_install_magic) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) (' = ') 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) ($ VSub_DollarName '$magic') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) ('; then\n') 
                  ('  # install mode needs the following variables:\n') ("  generated_by_libtool_version='") ($ VSub_DollarName '$macro_version') ("'\n") 
                  ("  notinst_deplibs='") ($ VSub_DollarName '$notinst_deplibs') ("'\n") ('else\n') ('  # When we are sourced in execute mode, ') 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) ('file and ') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) ('ECHO are already set.\n') 
                  ('  if test ') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) (libtool_execute_magic) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) (' != ') 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) ($ VSub_DollarName '$magic') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) ('; then\n') 
                  ('    file=') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) (0) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>)
                )
              }
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:qECHO)
                  op: Equal
                  rhs: 
                    {
                      (command_sub
                        left_token: <Left_Backtick '`'>
                        command_list: 
                          (command.CommandList
                            children: [
                              (command.Pipeline
                                children: [
                                  (C {($ VSub_DollarName '$ECHO')} {(DQ ($ VSub_DollarName '$ECHO'))})
                                  (C {($ VSub_DollarName '$SED')} 
                                    {(DQ ($ VSub_DollarName '$sed_quote_subst'))}
                                  )
                                ]
                                negated: F
                              )
                            ]
                          )
                      )
                    }
                )
              ]
            )
            (C {($ VSub_DollarName '$ECHO')} 
              {
                (DQ ('\n') ('# A function that is used when there is no print builtin or printf.\n') 
                  ('func_fallback_echo ()\n') ('{\n') ("  eval 'cat <<_LTECHO_EOF\n") (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) ('1\n') 
                  ("_LTECHO_EOF'\n") ('}\n') ('    ECHO=') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) 
                  ($ VSub_DollarName '$qECHO') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) ('\n') ('  fi\n') ('\n') 
                  ('# Very basic option parsing. These options are (a) specific to\n') ('# the libtool wrapper, (b) are identical between the wrapper\n') 
                  ('# /script/ and the wrapper /executable/ that is used only on\n') ('# windows platforms, and (c) all begin with the string ')
                ) (--lt-) 
                (DQ ('\n') ('# (application programs are unlikely to have options that match\n') 
                  ('# this pattern).\n') ('#\n') ('# There are only two supported options: --lt-debug and\n') 
                  ('# --lt-dump-script. There is, deliberately, no --lt-help.\n') ('#\n') ('# The first argument to this parsing function should be the\n') ("# script's ") 
                  ($ VSub_Number '$0') (' value, followed by ')
                ) ($ VSub_At '$@') 
                (DQ ('.\n') ('lt_option_debug=\n') ('func_parse_lt_options ()\n') ('{\n') 
                  ('  lt_script_arg0=') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) ('0\n') ('  shift\n') ('  for lt_opt\n') 
                  ('  do\n') ('    case ') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) (lt_opt) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) (' in\n') 
                  ('    --lt-debug) lt_option_debug=1 ;;\n') ('    --lt-dump-script)\n') ('        lt_dump_D=') 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\`'>) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) ('ECHO ') 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) (X) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) (lt_script_arg0) 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) (' | ') ($ VSub_DollarName '$SED') (" -e 's/^X//' -e 's%/[^/]*") (Lit_Other '$') ("%%'") 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\`'>) ('\n') ('        test ') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) (X) 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) (lt_dump_D) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) (' = ') 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) (X) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) (lt_script_arg0) 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) (' && lt_dump_D=.\n') ('        lt_dump_F=') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\`'>) 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) ('ECHO ') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) (X) 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) (lt_script_arg0) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) (' | ') 
                  ($ VSub_DollarName '$SED') (" -e 's/^X//' -e 's%^.*/%%'") (word_part.EscapedLiteral token:<Lit_EscapedChar '\\`'>) ('\n') 
                  ('        cat ') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) (lt_dump_D/) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) (lt_dump_F) 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) ('\n') ('        exit 0\n') ('      ;;\n') ('    --lt-*)\n') ('        ') 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) ('ECHO ') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) ("Unrecognized --lt- option: '") 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) ("lt_opt'") (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) (' 1>&2\n') ('        exit 1\n') 
                  ('      ;;\n') ('    esac\n') ('  done\n') ('\n') ('  # Print the debug banner immediately:\n') ('  if test -n ') 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) (lt_option_debug) 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) ('; then\n') ('    echo ') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) 
                  ($ VSub_DollarName '$outputname') (':') ($ VSub_DollarName '$output') (':') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) 
                  ('LINENO: libtool wrapper (GNU ') ($ VSub_DollarName '$PACKAGE') (') ') ($ VSub_DollarName '$VERSION') 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) (' 1>&2\n') ('  fi\n') ('}\n') ('\n') ('# Used when --lt-debug. Prints its arguments to stdout\n') 
                  ('# (redirection is the responsibility of the caller)\n') ('func_lt_dump_args ()\n') ('{\n') ('  lt_dump_args_N=1;\n') ('  for lt_arg\n') ('  do\n') ('    ') 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) ('ECHO ') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) ($ VSub_DollarName '$outputname') 
                  (':') ($ VSub_DollarName '$output') (':') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) 
                  ('LINENO: newargv[') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) ('lt_dump_args_N]: ') 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) (lt_arg) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) ('\n') ('    lt_dump_args_N=') 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\`'>) ('expr ') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) ('lt_dump_args_N + 1') 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\`'>) ('\n') ('  done\n') ('}\n') ('\n') ('# Core function for launching the target application\n') 
                  ('func_exec_program_core ()\n') ('{\n')
                )
              }
            )
            (command.Case
              to_match: {($ VSub_DollarName '$host')}
              arms: [
                (case_arm
                  pat_list: [
                    {(Lit_Star '*') (-) (Lit_Star '*') (-mingw)}
                    {(Lit_Star '*') (-) (Lit_Star '*') (-os2) (Lit_Star '*')}
                    {(Lit_Star '*') (-cegcc) (Lit_Star '*')}
                  ]
                  action: [
                    (C {($ VSub_DollarName '$ECHO')} 
                      {
                        (DQ ('      if test -n ') 
                          (word_part.EscapedLiteral
                            token: <Lit_EscapedChar '\\"'>
                          ) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) (lt_option_debug) 
                          (word_part.EscapedLiteral
                            token: <Lit_EscapedChar '\\"'>
                          ) ('; then\n') ('        ') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) ('ECHO ') 
                          (word_part.EscapedLiteral
                            token: <Lit_EscapedChar '\\"'>
                          ) ($ VSub_DollarName '$outputname') (':') ($ VSub_DollarName '$output') (':') 
                          (word_part.EscapedLiteral
                            token: <Lit_EscapedChar '\\$'>
                          ) ('LINENO: newargv[0]: ') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) (progdir) 
                          (word_part.EscapedLiteral
                            token: <Lit_EscapedChar '\\\\'>
                          ) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\\\'>) 
                          (word_part.EscapedLiteral
                            token: <Lit_EscapedChar '\\$'>
                          ) (program) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) (' 1>&2\n') 
                          ('        func_lt_dump_args ') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) ('{1+') 
                          (word_part.EscapedLiteral
                            token: <Lit_EscapedChar '\\"'>
                          ) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) ('@') 
                          (word_part.EscapedLiteral
                            token: <Lit_EscapedChar '\\"'>
                          ) ('} 1>&2\n') ('      fi\n') ('      exec ') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) 
                          (word_part.EscapedLiteral
                            token: <Lit_EscapedChar '\\$'>
                          ) (progdir) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\\\'>) 
                          (word_part.EscapedLiteral
                            token: <Lit_EscapedChar '\\\\'>
                          ) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) (program) 
                          (word_part.EscapedLiteral
                            token: <Lit_EscapedChar '\\"'>
                          ) (' ') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) ('{1+') 
                          (word_part.EscapedLiteral
                            token: <Lit_EscapedChar '\\"'>
                          ) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) ('@') 
                          (word_part.EscapedLiteral
                            token: <Lit_EscapedChar '\\"'>
                          ) ('}\n')
                        )
                      }
                    )
                  ]
                )
                (case_arm
                  pat_list: [{(Lit_Star '*')}]
                  action: [
                    (C {($ VSub_DollarName '$ECHO')} 
                      {
                        (DQ ('      if test -n ') 
                          (word_part.EscapedLiteral
                            token: <Lit_EscapedChar '\\"'>
                          ) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) (lt_option_debug) 
                          (word_part.EscapedLiteral
                            token: <Lit_EscapedChar '\\"'>
                          ) ('; then\n') ('        ') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) ('ECHO ') 
                          (word_part.EscapedLiteral
                            token: <Lit_EscapedChar '\\"'>
                          ) ($ VSub_DollarName '$outputname') (':') ($ VSub_DollarName '$output') (':') 
                          (word_part.EscapedLiteral
                            token: <Lit_EscapedChar '\\$'>
                          ) ('LINENO: newargv[0]: ') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) (progdir/) 
                          (word_part.EscapedLiteral
                            token: <Lit_EscapedChar '\\$'>
                          ) (program) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) (' 1>&2\n') 
                          ('        func_lt_dump_args ') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) ('{1+') 
                          (word_part.EscapedLiteral
                            token: <Lit_EscapedChar '\\"'>
                          ) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) ('@') 
                          (word_part.EscapedLiteral
                            token: <Lit_EscapedChar '\\"'>
                          ) ('} 1>&2\n') ('      fi\n') ('      exec ') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) 
                          (word_part.EscapedLiteral
                            token: <Lit_EscapedChar '\\$'>
                          ) (progdir/) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) (program) 
                          (word_part.EscapedLiteral
                            token: <Lit_EscapedChar '\\"'>
                          ) (' ') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) ('{1+') 
                          (word_part.EscapedLiteral
                            token: <Lit_EscapedChar '\\"'>
                          ) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) ('@') 
                          (word_part.EscapedLiteral
                            token: <Lit_EscapedChar '\\"'>
                          ) ('}\n')
                        )
                      }
                    )
                  ]
                )
              ]
            )
            (C {($ VSub_DollarName '$ECHO')} 
              {
                (DQ ('      ') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) ('ECHO ') 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) ('0: cannot exec ') 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) ('program ') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) ('*') 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) (' 1>&2\n') ('      exit 1\n') ('}\n') ('\n') 
                  ('# A function to encapsulate launching the target application\n') ('# Strips options in the --lt-* namespace from ') 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) ('@ and\n') ('# launches target application with the remaining arguments.\n') 
                  ('func_exec_program ()\n') ('{\n') ('  case ') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) (' ') 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) ('* ') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) (' in\n') ('  *') 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\\\'>) (' --lt-*)\n') ('    for lt_wr_arg\n') ('    do\n') ('      case ') 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) ('lt_wr_arg in\n') ('      --lt-*) ;;\n') ('      *) set x ') 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) ('@') 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) (' ') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) (lt_wr_arg) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) ('; shift;;\n') ('      esac\n') 
                  ('      shift\n') ('    done ;;\n') ('  esac\n') ('  func_exec_program_core ') 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) ('{1+') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) ('@') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) ('}\n') ('}\n') ('\n') 
                  ('  # Parse options\n') ('  func_parse_lt_options ') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) (0) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) (' ') 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) ('{1+') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) ('@') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) ('}\n') ('\n') 
                  ('  # Find the directory that this script lives in.\n') ('  thisdir=') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\`'>) 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) ('ECHO ') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) (file) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) (' | ') ($ VSub_DollarName '$SED') 
                  (" 's%/[^/]*") (Lit_Other '$') ("%%'") (word_part.EscapedLiteral token:<Lit_EscapedChar '\\`'>) ('\n') ('  test ') 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) (x) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) (thisdir) 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) (' = ') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) (x) 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) (file) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) (' && thisdir=.\n') ('\n') 
                  ('  # Follow symbolic links until we get to the real thisdir.\n') ('  file=') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\`'>) ('ls -ld ') 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) (file) 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) (' | ') ($ VSub_DollarName '$SED') (" -n 's/.*-> //p'") 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\`'>) ('\n') ('  while test -n ') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) (file) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) ('; do\n') ('    destdir=') 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\`'>) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) ('ECHO ') 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) (file) 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) (' | ') ($ VSub_DollarName '$SED') (" 's%/[^/]*") 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) ("%%'") (word_part.EscapedLiteral token:<Lit_EscapedChar '\\`'>) ('\n') ('\n') 
                  ('    # If there was a directory component, then change thisdir.\n') ('    if test ') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) (x) 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) (destdir) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) (' != ') 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) (x) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) (file) 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) ('; then\n') ('      case ') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) (destdir) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) (' in\n') ('      [') 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\\\'>) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\\\'>) ('/]* | [A-Za-z]:[') 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\\\'>) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\\\'>) ('/]*) thisdir=') 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) (destdir) 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) (' ;;\n') ('      *) thisdir=') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) (thisdir/) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) (destdir) 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) (' ;;\n') ('      esac\n') ('    fi\n') ('\n') ('    file=') 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\`'>) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) ('ECHO ') 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) (file) 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) (' | ') ($ VSub_DollarName '$SED') (" 's%^.*/%%'") 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\`'>) ('\n') ('    file=') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\`'>) ('ls -ld ') 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) (thisdir/) 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) (file) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) (' | ') ($ VSub_DollarName '$SED') 
                  (" -n 's/.*-> //p'") (word_part.EscapedLiteral token:<Lit_EscapedChar '\\`'>) ('\n') ('  done\n') ('\n') 
                  ("  # Usually 'no', except on cygwin/mingw when embedded into\n") ('  # the cwrapper.\n') ('  WRAPPER_SCRIPT_BELONGS_IN_OBJDIR=') 
                  ($ VSub_DollarName '$func_emit_wrapper_arg1') ('\n') ('  if test ') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) (WRAPPER_SCRIPT_BELONGS_IN_OBJDIR) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) (' = ') 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) (yes) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) ('; then\n') 
                  ("    # special case for '.'\n") ('    if test ') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) (thisdir) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) (' = ') 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) (.) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) ('; then\n') ('      thisdir=') 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\`'>) (pwd) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\`'>) ('\n') ('    fi\n') 
                  ('    # remove .libs from thisdir\n') ('    case ') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) (thisdir) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) (' in\n') ('    *[') 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\\\'>) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\\\'>) ('/]') ($ VSub_DollarName '$objdir') 
                  (' ) thisdir=') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\`'>) 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) ('ECHO ') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) (thisdir) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) (' | ') ($ VSub_DollarName '$SED') 
                  (" 's%[") (word_part.EscapedLiteral token:<Lit_EscapedChar '\\\\'>) 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\\\'>) ('/][^') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\\\'>) 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\\\'>) ('/]*') (Lit_Other '$') ("%%'") (word_part.EscapedLiteral token:<Lit_EscapedChar '\\`'>) (' ;;\n') 
                  ('    ') ($ VSub_DollarName '$objdir') (' )   thisdir=. ;;\n') ('    esac\n') ('  fi\n') ('\n') 
                  ('  # Try to get the absolute directory name.\n') ('  absdir=') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\`'>) ('cd ') 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) (thisdir) 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) (' && pwd') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\`'>) ('\n') ('  test -n ') 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) (absdir) 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) (' && thisdir=') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) (absdir) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) ('\n')
                )
              }
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: 
                        (C {(test)} {(yes)} {(Lit_Equals '=')} {(DQ ($ VSub_DollarName '$fast_install'))})
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (C {($ VSub_DollarName '$ECHO')} 
                      {
                        (DQ ("  program=lt-'") ($ VSub_DollarName '$outputname') ("'") 
                          ($ VSub_DollarName '$exeext') ('\n') ('  progdir=') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) 
                          (word_part.EscapedLiteral
                            token: <Lit_EscapedChar '\\$'>
                          ) (thisdir/) ($ VSub_DollarName '$objdir') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) ('\n') 
                          ('\n') ('  if test ! -f ') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) 
                          (word_part.EscapedLiteral
                            token: <Lit_EscapedChar '\\$'>
                          ) (progdir/) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) (program) 
                          (word_part.EscapedLiteral
                            token: <Lit_EscapedChar '\\"'>
                          ) (' ||\n') ('     { file=') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\`'>) ('ls -1dt ') 
                          (word_part.EscapedLiteral
                            token: <Lit_EscapedChar '\\"'>
                          ) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) (progdir/) 
                          (word_part.EscapedLiteral
                            token: <Lit_EscapedChar '\\$'>
                          ) (program) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) (' ') 
                          (word_part.EscapedLiteral
                            token: <Lit_EscapedChar '\\"'>
                          ) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) (progdir/../) 
                          (word_part.EscapedLiteral
                            token: <Lit_EscapedChar '\\$'>
                          ) (program) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) (' 2>/dev/null | ') 
                          ($ VSub_DollarName '$SED') (' 1q') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\`'>) ('; ') 
                          (word_part.EscapedLiteral
                            token: <Lit_EscapedChar '\\\\'>
                          ) ('\n') ('       test ') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) (X) 
                          (word_part.EscapedLiteral
                            token: <Lit_EscapedChar '\\$'>
                          ) (file) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) (' != ') 
                          (word_part.EscapedLiteral
                            token: <Lit_EscapedChar '\\"'>
                          ) (X) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) (progdir/) 
                          (word_part.EscapedLiteral
                            token: <Lit_EscapedChar '\\$'>
                          ) (program) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) ('; }; then\n') ('\n') ('    file=') 
                          (word_part.EscapedLiteral
                            token: <Lit_EscapedChar '\\"'>
                          ) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) 
                          (word_part.EscapedLiteral
                            token: <Lit_EscapedChar '\\$'>
                          ) (-) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) (program) 
                          (word_part.EscapedLiteral
                            token: <Lit_EscapedChar '\\"'>
                          ) ('\n') ('\n') ('    if test ! -d ') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) 
                          (word_part.EscapedLiteral
                            token: <Lit_EscapedChar '\\$'>
                          ) (progdir) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) ('; then\n') ('      ') 
                          ($ VSub_DollarName '$MKDIR') (' ') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) 
                          (word_part.EscapedLiteral
                            token: <Lit_EscapedChar '\\$'>
                          ) (progdir) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) ('\n') ('    else\n') ('      ') 
                          ($ VSub_DollarName '$RM') (' ') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) 
                          (word_part.EscapedLiteral
                            token: <Lit_EscapedChar '\\$'>
                          ) (progdir/) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) (file) 
                          (word_part.EscapedLiteral
                            token: <Lit_EscapedChar '\\"'>
                          ) ('\n') ('    fi')
                        )
                      }
                    )
                    (C {($ VSub_DollarName '$ECHO')} 
                      {
                        (DQ ('\n') ('    # relink executable if necessary\n') ('    if test -n ') 
                          (word_part.EscapedLiteral
                            token: <Lit_EscapedChar '\\"'>
                          ) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) (relink_command) 
                          (word_part.EscapedLiteral
                            token: <Lit_EscapedChar '\\"'>
                          ) ('; then\n') ('      if relink_command_output=') 
                          (word_part.EscapedLiteral
                            token: <Lit_EscapedChar '\\`'>
                          ) ('eval ') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) ('relink_command 2>&1') 
                          (word_part.EscapedLiteral
                            token: <Lit_EscapedChar '\\`'>
                          ) ('; then :\n') ('      else\n') ('\t') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) ('ECHO ') 
                          (word_part.EscapedLiteral
                            token: <Lit_EscapedChar '\\"'>
                          ) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) (relink_command_output) 
                          (word_part.EscapedLiteral
                            token: <Lit_EscapedChar '\\"'>
                          ) (' >&2\n') ('\t') ($ VSub_DollarName '$RM') (' ') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) 
                          (word_part.EscapedLiteral
                            token: <Lit_EscapedChar '\\$'>
                          ) (progdir/) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) (file) 
                          (word_part.EscapedLiteral
                            token: <Lit_EscapedChar '\\"'>
                          ) ('\n') ('\texit 1\n') ('      fi\n') ('    fi\n') ('\n') ('    ') ($ VSub_DollarName '$MV') (' ') 
                          (word_part.EscapedLiteral
                            token: <Lit_EscapedChar '\\"'>
                          ) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) (progdir/) 
                          (word_part.EscapedLiteral
                            token: <Lit_EscapedChar '\\$'>
                          ) (file) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) (' ') 
                          (word_part.EscapedLiteral
                            token: <Lit_EscapedChar '\\"'>
                          ) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) (progdir/) 
                          (word_part.EscapedLiteral
                            token: <Lit_EscapedChar '\\$'>
                          ) (program) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) (' 2>/dev/null ||\n') ('    { ') 
                          ($ VSub_DollarName '$RM') (' ') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) 
                          (word_part.EscapedLiteral
                            token: <Lit_EscapedChar '\\$'>
                          ) (progdir/) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) (program) 
                          (word_part.EscapedLiteral
                            token: <Lit_EscapedChar '\\"'>
                          ) (';\n') ('      ') ($ VSub_DollarName '$MV') (' ') 
                          (word_part.EscapedLiteral
                            token: <Lit_EscapedChar '\\"'>
                          ) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) (progdir/) 
                          (word_part.EscapedLiteral
                            token: <Lit_EscapedChar '\\$'>
                          ) (file) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) (' ') 
                          (word_part.EscapedLiteral
                            token: <Lit_EscapedChar '\\"'>
                          ) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) (progdir/) 
                          (word_part.EscapedLiteral
                            token: <Lit_EscapedChar '\\$'>
                          ) (program) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) ('; }\n') ('    ') 
                          ($ VSub_DollarName '$RM') (' ') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) 
                          (word_part.EscapedLiteral
                            token: <Lit_EscapedChar '\\$'>
                          ) (progdir/) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) (file) 
                          (word_part.EscapedLiteral
                            token: <Lit_EscapedChar '\\"'>
                          ) ('\n') ('  fi')
                        )
                      }
                    )
                  ]
                )
              ]
              else_action: [
                (C {($ VSub_DollarName '$ECHO')} 
                  {
                    (DQ ("  program='") ($ VSub_DollarName '$outputname') ("'\n") ('  progdir=') 
                      (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) (thisdir/) ($ VSub_DollarName '$objdir') 
                      (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) ('\n')
                    )
                  }
                )
              ]
            )
            (C {($ VSub_DollarName '$ECHO')} 
              {
                (DQ ('\n') ('  if test -f ') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) (progdir/) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) (program) 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) ('; then')
                )
              }
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$dllsearchpath'))})
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (C {($ VSub_DollarName '$ECHO')} 
                      {
                        (DQ ('    # Add the dll search path components to the executable PATH\n') 
                          ('    PATH=') ($ VSub_DollarName '$dllsearchpath') (':') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) 
                          ('PATH\n')
                        )
                      }
                    )
                  ]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: 
                        (command.AndOr
                          ops: [Op_DAmp Op_DAmp]
                          children: [
                            (C {(test)} {(yes)} {(Lit_Equals '=')} 
                              {(DQ ($ VSub_DollarName '$shlibpath_overrides_runpath'))}
                            )
                            (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$shlibpath_var'))})
                            (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$temp_rpath'))})
                          ]
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (C {($ VSub_DollarName '$ECHO')} 
                      {
                        (DQ ('    # Add our own library path to ') 
                          ($ VSub_DollarName '$shlibpath_var') ('\n') ('    ') ($ VSub_DollarName '$shlibpath_var') ('=') 
                          (word_part.EscapedLiteral
                            token: <Lit_EscapedChar '\\"'>
                          ) ($ VSub_DollarName '$temp_rpath') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) 
                          ($ VSub_DollarName '$shlibpath_var') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) ('\n') ('\n') 
                          ('    # Some systems cannot cope with colon-terminated ') ($ VSub_DollarName '$shlibpath_var') ('\n') 
                          ('    # The second colon is a workaround for a bug in BeOS R4 sed\n') ('    ') ($ VSub_DollarName '$shlibpath_var') ('=') 
                          (word_part.EscapedLiteral
                            token: <Lit_EscapedChar '\\`'>
                          ) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) ('ECHO ') 
                          (word_part.EscapedLiteral
                            token: <Lit_EscapedChar '\\"'>
                          ) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) ($ VSub_DollarName '$shlibpath_var') 
                          (word_part.EscapedLiteral
                            token: <Lit_EscapedChar '\\"'>
                          ) (' | ') ($ VSub_DollarName '$SED') (" 's/::*") (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) 
                          ("//'") (word_part.EscapedLiteral token:<Lit_EscapedChar '\\`'>) ('\n') ('\n') ('    export ') 
                          ($ VSub_DollarName '$shlibpath_var') ('\n')
                        )
                      }
                    )
                  ]
                )
              ]
            )
            (C {($ VSub_DollarName '$ECHO')} 
              {
                (DQ ('    if test ') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) (libtool_execute_magic) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) (' != ') 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) ($ VSub_DollarName '$magic') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) ('; then\n') 
                  ('      # Run the actual program with our arguments.\n') ('      func_exec_program ') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) ('{1+') 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) ('@') 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) ('}\n') ('    fi\n') ('  else\n') ("    # The program doesn't exist.\n") ('    ') 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) ('ECHO ') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) ("0: error: '") (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) (progdir/) 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) ("program' does not exist") (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) (' 1>&2\n') 
                  ('    ') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) ('ECHO ') 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) ('This script is just a wrapper for ') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) 
                  (program.) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) (' 1>&2\n') ('    ') 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) ('ECHO ') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) ('See the ') 
                  ($ VSub_DollarName '$PACKAGE') (' documentation for more information.') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) 
                  (' 1>&2\n') ('    exit 1\n') ('  fi\n') (fi)
                )
              }
            )
          ]
        )
    )
    (command.ShFunction
      name: func_emit_cwrapperexe_src
      body: 
        (command.BraceGroup
          children: [
            (command.Simple
              words: [{(cat)}]
              redirects: [
                (redir.HereDoc
                  op: <Redir_DLess '<<'>
                  fd: 16777215
                  here_begin: {(EOF)}
                  here_end_span_id: 27604
                  stdin_parts: [
                    ('\n')
                    ('/* ')
                    ($ VSub_DollarName '$cwrappersource')
                    (' - temporary wrapper executable for ')
                    ($ VSub_DollarName '$objdir')
                    (/)
                    ($ VSub_DollarName '$outputname')
                    ('\n')
                    ('   Generated by ')
                    ($ VSub_DollarName '$PROGRAM')
                    (' (GNU ')
                    ($ VSub_DollarName '$PACKAGE')
                    (') ')
                    ($ VSub_DollarName '$VERSION')
                    ('\n')
                    ('\n')
                    ('   The ')
                    ($ VSub_DollarName '$output')
                    (' program cannot be directly executed until all the libtool\n')
                    ('   libraries that it depends on are installed.\n')
                    ('\n')
                    (
'   This wrapper executable should never be moved out of the build directory.\n'
                    )
                    ('   If it is, it will not operate correctly.\n')
                    ('*/\n')
                  ]
                )
              ]
            )
            (command.Simple
              words: [{(cat)}]
              redirects: [
                (redir.HereDoc
                  op: <Redir_DLess '<<'>
                  fd: 16777215
                  here_begin: {(DQ (EOF))}
                  here_end_span_id: 27758
                  stdin_parts: [
                    ('#ifdef _MSC_VER\n')
                    ('# define _CRT_SECURE_NO_DEPRECATE 1\n')
                    ('#endif\n')
                    ('#include <stdio.h>\n')
                    ('#include <stdlib.h>\n')
                    ('#ifdef _MSC_VER\n')
                    ('# include <direct.h>\n')
                    ('# include <process.h>\n')
                    ('# include <io.h>\n')
                    ('#else\n')
                    ('# include <unistd.h>\n')
                    ('# include <stdint.h>\n')
                    ('# ifdef __CYGWIN__\n')
                    ('#  include <io.h>\n')
                    ('# endif\n')
                    ('#endif\n')
                    ('#include <malloc.h>\n')
                    ('#include <stdarg.h>\n')
                    ('#include <assert.h>\n')
                    ('#include <string.h>\n')
                    ('#include <ctype.h>\n')
                    ('#include <errno.h>\n')
                    ('#include <fcntl.h>\n')
                    ('#include <sys/stat.h>\n')
                    ('\n')
                    ('#define STREQ(s1, s2) (strcmp ((s1), (s2)) == 0)\n')
                    ('\n')
                    ('/* declarations of non-ANSI functions */\n')
                    ('#if defined __MINGW32__\n')
                    ('# ifdef __STRICT_ANSI__\n')
                    ('int _putenv (const char *);\n')
                    ('# endif\n')
                    ('#elif defined __CYGWIN__\n')
                    ('# ifdef __STRICT_ANSI__\n')
                    ('char *realpath (const char *, char *);\n')
                    ('int putenv (char *);\n')
                    ('int setenv (const char *, const char *, int);\n')
                    ('# endif\n')
                    ('/* #elif defined other_platform || defined ... */\n')
                    ('#endif\n')
                    ('\n')
                    ('/* portability defines, excluding path handling macros */\n')
                    ('#if defined _MSC_VER\n')
                    ('# define setmode _setmode\n')
                    ('# define stat    _stat\n')
                    ('# define chmod   _chmod\n')
                    ('# define getcwd  _getcwd\n')
                    ('# define putenv  _putenv\n')
                    ('# define S_IXUSR _S_IEXEC\n')
                    ('#elif defined __MINGW32__\n')
                    ('# define setmode _setmode\n')
                    ('# define stat    _stat\n')
                    ('# define chmod   _chmod\n')
                    ('# define getcwd  _getcwd\n')
                    ('# define putenv  _putenv\n')
                    ('#elif defined __CYGWIN__\n')
                    ('# define HAVE_SETENV\n')
                    ('# define FOPEN_WB "wb"\n')
                    ('/* #elif defined other platforms ... */\n')
                    ('#endif\n')
                    ('\n')
                    ('#if defined PATH_MAX\n')
                    ('# define LT_PATHMAX PATH_MAX\n')
                    ('#elif defined MAXPATHLEN\n')
                    ('# define LT_PATHMAX MAXPATHLEN\n')
                    ('#else\n')
                    ('# define LT_PATHMAX 1024\n')
                    ('#endif\n')
                    ('\n')
                    ('#ifndef S_IXOTH\n')
                    ('# define S_IXOTH 0\n')
                    ('#endif\n')
                    ('#ifndef S_IXGRP\n')
                    ('# define S_IXGRP 0\n')
                    ('#endif\n')
                    ('\n')
                    ('/* path handling portability macros */\n')
                    ('#ifndef DIR_SEPARATOR\n')
                    ("# define DIR_SEPARATOR '/'\n")
                    ("# define PATH_SEPARATOR ':'\n")
                    ('#endif\n')
                    ('\n')
                    ('#if defined _WIN32 || defined __MSDOS__ || defined __DJGPP__ || \\\n')
                    ('  defined __OS2__\n')
                    ('# define HAVE_DOS_BASED_FILE_SYSTEM\n')
                    ('# define FOPEN_WB "wb"\n')
                    ('# ifndef DIR_SEPARATOR_2\n')
                    ("#  define DIR_SEPARATOR_2 '\\\\'\n")
                    ('# endif\n')
                    ('# ifndef PATH_SEPARATOR_2\n')
                    ("#  define PATH_SEPARATOR_2 ';'\n")
                    ('# endif\n')
                    ('#endif\n')
                    ('\n')
                    ('#ifndef DIR_SEPARATOR_2\n')
                    ('# define IS_DIR_SEPARATOR(ch) ((ch) == DIR_SEPARATOR)\n')
                    ('#else /* DIR_SEPARATOR_2 */\n')
                    ('# define IS_DIR_SEPARATOR(ch) \\\n')
                    ('\t(((ch) == DIR_SEPARATOR) || ((ch) == DIR_SEPARATOR_2))\n')
                    ('#endif /* DIR_SEPARATOR_2 */\n')
                    ('\n')
                    ('#ifndef PATH_SEPARATOR_2\n')
                    ('# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR)\n')
                    ('#else /* PATH_SEPARATOR_2 */\n')
                    ('# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR_2)\n')
                    ('#endif /* PATH_SEPARATOR_2 */\n')
                    ('\n')
                    ('#ifndef FOPEN_WB\n')
                    ('# define FOPEN_WB "w"\n')
                    ('#endif\n')
                    ('#ifndef _O_BINARY\n')
                    ('# define _O_BINARY 0\n')
                    ('#endif\n')
                    ('\n')
                    ('#define XMALLOC(type, num)      ((type *) xmalloc ((num) * sizeof(type)))\n')
                    ('#define XFREE(stale) do { \\\n')
                    ('  if (stale) { free (stale); stale = 0; } \\\n')
                    ('} while (0)\n')
                    ('\n')
                    ('#if defined LT_DEBUGWRAPPER\n')
                    ('static int lt_debug = 1;\n')
                    ('#else\n')
                    ('static int lt_debug = 0;\n')
                    ('#endif\n')
                    ('\n')
                    ('const char *program_name = "libtool-wrapper"; /* in case xstrdup fails */\n')
                    ('\n')
                    ('void *xmalloc (size_t num);\n')
                    ('char *xstrdup (const char *string);\n')
                    ('const char *base_name (const char *name);\n')
                    ('char *find_executable (const char *wrapper);\n')
                    ('char *chase_symlinks (const char *pathspec);\n')
                    ('int make_executable (const char *path);\n')
                    ('int check_executable (const char *path);\n')
                    ('char *strendzap (char *str, const char *pat);\n')
                    ('void lt_debugprintf (const char *file, int line, const char *fmt, ...);\n')
                    ('void lt_fatal (const char *file, int line, const char *message, ...);\n')
                    ('static const char *nonnull (const char *s);\n')
                    ('static const char *nonempty (const char *s);\n')
                    ('void lt_setenv (const char *name, const char *value);\n')
                    ('char *lt_extend_str (const char *orig_value, const char *add, int to_end);\n')
                    ('void lt_update_exe_path (const char *name, const char *value);\n')
                    ('void lt_update_lib_path (const char *name, const char *value);\n')
                    ('char **prepare_spawn (char **argv);\n')
                    ('void lt_dump_script (FILE *f);\n')
                  ]
                )
              ]
            )
            (command.Simple
              words: [{(cat)}]
              redirects: [
                (redir.HereDoc
                  op: <Redir_DLess '<<'>
                  fd: 16777215
                  here_begin: {(EOF)}
                  here_end_span_id: 27782
                  stdin_parts: [
                    ('#if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 5)\n')
                    ('# define externally_visible volatile\n')
                    ('#else\n')
                    ('# define externally_visible __attribute__((externally_visible)) volatile\n')
                    ('#endif\n')
                    ('externally_visible const char * MAGIC_EXE = ')
                    (Right_DoubleQuote '"')
                    ($ VSub_DollarName '$magic_exe')
                    (Right_DoubleQuote '"')
                    (';\n')
                    ('const char * LIB_PATH_VARNAME = ')
                    (Right_DoubleQuote '"')
                    ($ VSub_DollarName '$shlibpath_var')
                    (Right_DoubleQuote '"')
                    (';\n')
                  ]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: 
                        (command.AndOr
                          ops: [Op_DAmp Op_DAmp]
                          children: [
                            (C {(test)} {(yes)} {(Lit_Equals '=')} 
                              {(DQ ($ VSub_DollarName '$shlibpath_overrides_runpath'))}
                            )
                            (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$shlibpath_var'))})
                            (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$temp_rpath'))})
                          ]
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (C {(func_to_host_path)} {(DQ ($ VSub_DollarName '$temp_rpath'))})
                    (command.Simple
                      words: [{(cat)}]
                      redirects: [
                        (redir.HereDoc
                          op: <Redir_DLess '<<'>
                          fd: 16777215
                          here_begin: {(EOF)}
                          here_end_span_id: 27839
                          stdin_parts: [
                            ('const char * LIB_PATH_VALUE   = ')
                            (Right_DoubleQuote '"')
                            ($ VSub_DollarName '$func_to_host_path_result')
                            (Right_DoubleQuote '"')
                            (';\n')
                          ]
                        )
                      ]
                    )
                  ]
                )
              ]
              else_action: [
                (command.Simple
                  words: [{(cat)}]
                  redirects: [
                    (redir.HereDoc
                      op: <Redir_DLess '<<'>
                      fd: 16777215
                      here_begin: {(DQ (EOF))}
                      here_end_span_id: 27852
                      stdin_parts: [('const char * LIB_PATH_VALUE   = "";\n')]
                    )
                  ]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$dllsearchpath'))})
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (C {(func_to_host_path)} {(DQ ($ VSub_DollarName '$dllsearchpath') (':'))})
                    (command.Simple
                      words: [{(cat)}]
                      redirects: [
                        (redir.HereDoc
                          op: <Redir_DLess '<<'>
                          fd: 16777215
                          here_begin: {(EOF)}
                          here_end_span_id: 27896
                          stdin_parts: [
                            ('const char * EXE_PATH_VARNAME = ')
                            (Right_DoubleQuote '"')
                            (PATH)
                            (Right_DoubleQuote '"')
                            (';\n')
                            ('const char * EXE_PATH_VALUE   = ')
                            (Right_DoubleQuote '"')
                            ($ VSub_DollarName '$func_to_host_path_result')
                            (Right_DoubleQuote '"')
                            (';\n')
                          ]
                        )
                      ]
                    )
                  ]
                )
              ]
              else_action: [
                (command.Simple
                  words: [{(cat)}]
                  redirects: [
                    (redir.HereDoc
                      op: <Redir_DLess '<<'>
                      fd: 16777215
                      here_begin: {(DQ (EOF))}
                      here_end_span_id: 27910
                      stdin_parts: [
                        ('const char * EXE_PATH_VARNAME = "";\n')
                        ('const char * EXE_PATH_VALUE   = "";\n')
                      ]
                    )
                  ]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: 
                        (C {(test)} {(yes)} {(Lit_Equals '=')} {(DQ ($ VSub_DollarName '$fast_install'))})
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (command.Simple
                      words: [{(cat)}]
                      redirects: [
                        (redir.HereDoc
                          op: <Redir_DLess '<<'>
                          fd: 16777215
                          here_begin: {(EOF)}
                          here_end_span_id: 27944
                          stdin_parts: [
                            ('const char * TARGET_PROGRAM_NAME = ')
                            (Right_DoubleQuote '"')
                            (lt-)
                            ($ VSub_DollarName '$outputname')
                            (Right_DoubleQuote '"')
                            ('; /* hopefully, no .exe */\n')
                          ]
                        )
                      ]
                    )
                  ]
                )
              ]
              else_action: [
                (command.Simple
                  words: [{(cat)}]
                  redirects: [
                    (redir.HereDoc
                      op: <Redir_DLess '<<'>
                      fd: 16777215
                      here_begin: {(EOF)}
                      here_end_span_id: 27960
                      stdin_parts: [
                        ('const char * TARGET_PROGRAM_NAME = ')
                        (Right_DoubleQuote '"')
                        ($ VSub_DollarName '$outputname')
                        (Right_DoubleQuote '"')
                        ('; /* hopefully, no .exe */\n')
                      ]
                    )
                  ]
                )
              ]
            )
            (command.Simple
              words: [{(cat)}]
              redirects: [
                (redir.HereDoc
                  op: <Redir_DLess '<<'>
                  fd: 16777215
                  here_begin: {(DQ (EOF))}
                  here_end_span_id: 28007
                  stdin_parts: [
                    ('\n')
                    ('#define LTWRAPPER_OPTION_PREFIX         "--lt-"\n')
                    ('\n')
                    ('static const char *ltwrapper_option_prefix = LTWRAPPER_OPTION_PREFIX;\n')
                    (
'static const char *dumpscript_opt       = LTWRAPPER_OPTION_PREFIX "dump-script";\n'
                    )
                    ('static const char *debug_opt            = LTWRAPPER_OPTION_PREFIX "debug";\n')
                    ('\n')
                    ('int\n')
                    ('main (int argc, char *argv[])\n')
                    ('{\n')
                    ('  char **newargz;\n')
                    ('  int  newargc;\n')
                    ('  char *tmp_pathspec;\n')
                    ('  char *actual_cwrapper_path;\n')
                    ('  char *actual_cwrapper_name;\n')
                    ('  char *target_name;\n')
                    ('  char *lt_argv_zero;\n')
                    ('  int rval = 127;\n')
                    ('\n')
                    ('  int i;\n')
                    ('\n')
                    ('  program_name = (char *) xstrdup (base_name (argv[0]));\n')
                    ('  newargz = XMALLOC (char *, (size_t) argc + 1);\n')
                    ('\n')
                    ("  /* very simple arg parsing; don't want to rely on getopt\n")
                    ('   * also, copy all non cwrapper options to newargz, except\n')
                    ('   * argz[0], which is handled differently\n')
                    ('   */\n')
                    ('  newargc=0;\n')
                    ('  for (i = 1; i < argc; i++)\n')
                    ('    {\n')
                    ('      if (STREQ (argv[i], dumpscript_opt))\n')
                    ('\t{\n')
                  ]
                )
              ]
            )
            (command.Case
              to_match: {($ VSub_DollarName '$host')}
              arms: [
                (case_arm
                  pat_list: [
                    {(Lit_Star '*') (mingw) (Lit_Star '*')}
                    {(Lit_Star '*') (cygwin) (Lit_Star '*')}
                  ]
                  action: [(C {(echo)} {(DQ ('          setmode(1,_O_BINARY);'))})]
                )
              ]
            )
            (command.Simple
              words: [{(cat)}]
              redirects: [
                (redir.HereDoc
                  op: <Redir_DLess '<<'>
                  fd: 16777215
                  here_begin: {(DQ (EOF))}
                  here_end_span_id: 28082
                  stdin_parts: [
                    ('\t  lt_dump_script (stdout);\n')
                    ('\t  return 0;\n')
                    ('\t}\n')
                    ('      if (STREQ (argv[i], debug_opt))\n')
                    ('\t{\n')
                    ('          lt_debug = 1;\n')
                    ('          continue;\n')
                    ('\t}\n')
                    ('      if (STREQ (argv[i], ltwrapper_option_prefix))\n')
                    ('        {\n')
                    ('          /* however, if there is an option in the LTWRAPPER_OPTION_PREFIX\n')
                    ('             namespace, but it is not one of the ones we know about and\n')
                    ('             have already dealt with, above (inluding dump-script), then\n')
                    ('             report an error. Otherwise, targets might begin to believe\n')
                    (
'             they are allowed to use options in the LTWRAPPER_OPTION_PREFIX\n'
                    )
                    (
"             namespace. The first time any user complains about this, we'll\n"
                    )
                    ('             need to make LTWRAPPER_OPTION_PREFIX a configure-time option\n')
                    ('             or a configure.ac-settable value.\n')
                    ('           */\n')
                    ('          lt_fatal (__FILE__, __LINE__,\n')
                    ('\t\t    "unrecognized %s option: \'%s\'",\n')
                    ('                    ltwrapper_option_prefix, argv[i]);\n')
                    ('        }\n')
                    ('      /* otherwise ... */\n')
                    ('      newargz[++newargc] = xstrdup (argv[i]);\n')
                    ('    }\n')
                    ('  newargz[++newargc] = NULL;\n')
                    ('\n')
                  ]
                )
              ]
            )
            (command.Simple
              words: [{(cat)}]
              redirects: [
                (redir.HereDoc
                  op: <Redir_DLess '<<'>
                  fd: 16777215
                  here_begin: {(EOF)}
                  here_end_span_id: 28101
                  stdin_parts: [
                    ('  /* The GNU banner must be the first non-error debug message */\n')
                    ('  lt_debugprintf (__FILE__, __LINE__, ')
                    (Right_DoubleQuote '"')
                    ('libtool wrapper (GNU ')
                    ($ VSub_DollarName '$PACKAGE')
                    (') ')
                    ($ VSub_DollarName '$VERSION')
                    (Lit_Other '\\')
                    (n)
                    (Right_DoubleQuote '"')
                    (');\n')
                  ]
                )
              ]
            )
            (command.Simple
              words: [{(cat)}]
              redirects: [
                (redir.HereDoc
                  op: <Redir_DLess '<<'>
                  fd: 16777215
                  here_begin: {(DQ (EOF))}
                  here_end_span_id: 28147
                  stdin_parts: [
                    ('  lt_debugprintf (__FILE__, __LINE__, "(main) argv[0]: %s\\n", argv[0]);\n')
                    (
'  lt_debugprintf (__FILE__, __LINE__, "(main) program_name: %s\\n", program_name);\n'
                    )
                    ('\n')
                    ('  tmp_pathspec = find_executable (argv[0]);\n')
                    ('  if (tmp_pathspec == NULL)\n')
                    ('    lt_fatal (__FILE__, __LINE__, "couldn\'t find %s", argv[0]);\n')
                    ('  lt_debugprintf (__FILE__, __LINE__,\n')
                    ('                  "(main) found exe (before symlink chase) at: %s\\n",\n')
                    ('\t\t  tmp_pathspec);\n')
                    ('\n')
                    ('  actual_cwrapper_path = chase_symlinks (tmp_pathspec);\n')
                    ('  lt_debugprintf (__FILE__, __LINE__,\n')
                    ('                  "(main) found exe (after symlink chase) at: %s\\n",\n')
                    ('\t\t  actual_cwrapper_path);\n')
                    ('  XFREE (tmp_pathspec);\n')
                    ('\n')
                    ('  actual_cwrapper_name = xstrdup (base_name (actual_cwrapper_path));\n')
                    ('  strendzap (actual_cwrapper_path, actual_cwrapper_name);\n')
                    ('\n')
                    ('  /* wrapper name transforms */\n')
                    ('  strendzap (actual_cwrapper_name, ".exe");\n')
                    ('  tmp_pathspec = lt_extend_str (actual_cwrapper_name, ".exe", 1);\n')
                    ('  XFREE (actual_cwrapper_name);\n')
                    ('  actual_cwrapper_name = tmp_pathspec;\n')
                    ('  tmp_pathspec = 0;\n')
                    ('\n')
                    (
'  /* target_name transforms -- use actual target program name; might have lt- prefix */\n'
                    )
                    ('  target_name = xstrdup (base_name (TARGET_PROGRAM_NAME));\n')
                    ('  strendzap (target_name, ".exe");\n')
                    ('  tmp_pathspec = lt_extend_str (target_name, ".exe", 1);\n')
                    ('  XFREE (target_name);\n')
                    ('  target_name = tmp_pathspec;\n')
                    ('  tmp_pathspec = 0;\n')
                    ('\n')
                    ('  lt_debugprintf (__FILE__, __LINE__,\n')
                    ('\t\t  "(main) libtool target name: %s\\n",\n')
                    ('\t\t  target_name);\n')
                  ]
                )
              ]
            )
            (command.Simple
              words: [{(cat)}]
              redirects: [
                (redir.HereDoc
                  op: <Redir_DLess '<<'>
                  fd: 16777215
                  here_begin: {(EOF)}
                  here_end_span_id: 28174
                  stdin_parts: [
                    ('  newargz[0] =\n')
                    ('    XMALLOC (char, (strlen (actual_cwrapper_path) +\n')
                    ('\t\t    strlen (')
                    (Right_DoubleQuote '"')
                    ($ VSub_DollarName '$objdir')
                    (Right_DoubleQuote '"')
                    (') + 1 + strlen (actual_cwrapper_name) + 1));\n')
                    ('  strcpy (newargz[0], actual_cwrapper_path);\n')
                    ('  strcat (newargz[0], ')
                    (Right_DoubleQuote '"')
                    ($ VSub_DollarName '$objdir')
                    (Right_DoubleQuote '"')
                    (');\n')
                    ('  strcat (newargz[0], ')
                    (Right_DoubleQuote '"')
                    (/)
                    (Right_DoubleQuote '"')
                    (');\n')
                  ]
                )
              ]
            )
            (command.Simple
              words: [{(cat)}]
              redirects: [
                (redir.HereDoc
                  op: <Redir_DLess '<<'>
                  fd: 16777215
                  here_begin: {(DQ (EOF))}
                  here_end_span_id: 28194
                  stdin_parts: [
                    ("  /* stop here, and copy so we don't have to do this twice */\n")
                    ('  tmp_pathspec = xstrdup (newargz[0]);\n')
                    ('\n')
                    ('  /* do NOT want the lt- prefix here, so use actual_cwrapper_name */\n')
                    ('  strcat (newargz[0], actual_cwrapper_name);\n')
                    ('\n')
                    ('  /* DO want the lt- prefix here if it exists, so use target_name */\n')
                    ('  lt_argv_zero = lt_extend_str (tmp_pathspec, target_name, 1);\n')
                    ('  XFREE (tmp_pathspec);\n')
                    ('  tmp_pathspec = NULL;\n')
                  ]
                )
              ]
            )
            (command.Case
              to_match: {($ VSub_DollarName '$host_os')}
              arms: [
                (case_arm
                  pat_list: [{(mingw) (Lit_Star '*')}]
                  action: [
                    (command.Simple
                      words: [{(cat)}]
                      redirects: [
                        (redir.HereDoc
                          op: <Redir_DLess '<<'>
                          fd: 16777215
                          here_begin: {(DQ (EOF))}
                          here_end_span_id: 28227
                          stdin_parts: [
                            ('  {\n')
                            ('    char* p;\n')
                            ("    while ((p = strchr (newargz[0], '\\\\')) != NULL)\n")
                            ('      {\n')
                            ("\t*p = '/';\n")
                            ('      }\n')
                            ("    while ((p = strchr (lt_argv_zero, '\\\\')) != NULL)\n")
                            ('      {\n')
                            ("\t*p = '/';\n")
                            ('      }\n')
                            ('  }\n')
                          ]
                        )
                      ]
                    )
                  ]
                )
              ]
            )
            (command.Simple
              words: [{(cat)}]
              redirects: [
                (redir.HereDoc
                  op: <Redir_DLess '<<'>
                  fd: 16777215
                  here_begin: {(DQ (EOF))}
                  here_end_span_id: 28264
                  stdin_parts: [
                    ('  XFREE (target_name);\n')
                    ('  XFREE (actual_cwrapper_path);\n')
                    ('  XFREE (actual_cwrapper_name);\n')
                    ('\n')
                    ('  lt_setenv ("BIN_SH", "xpg4"); /* for Tru64 */\n')
                    ('  lt_setenv ("DUALCASE", "1");  /* for MSK sh */\n')
                    ('  /* Update the DLL searchpath.  EXE_PATH_VALUE ($dllsearchpath) must\n')
                    (
'     be prepended before (that is, appear after) LIB_PATH_VALUE ($temp_rpath)\n'
                    )
                    ('     because on Windows, both *_VARNAMEs are PATH but uninstalled\n')
                    ('     libraries must come first. */\n')
                    ('  lt_update_exe_path (EXE_PATH_VARNAME, EXE_PATH_VALUE);\n')
                    ('  lt_update_lib_path (LIB_PATH_VARNAME, LIB_PATH_VALUE);\n')
                    ('\n')
                    ('  lt_debugprintf (__FILE__, __LINE__, "(main) lt_argv_zero: %s\\n",\n')
                    ('\t\t  nonnull (lt_argv_zero));\n')
                    ('  for (i = 0; i < newargc; i++)\n')
                    ('    {\n')
                    ('      lt_debugprintf (__FILE__, __LINE__, "(main) newargz[%d]: %s\\n",\n')
                    ('\t\t      i, nonnull (newargz[i]));\n')
                    ('    }\n')
                    ('\n')
                  ]
                )
              ]
            )
            (command.Case
              to_match: {($ VSub_DollarName '$host_os')}
              arms: [
                (case_arm
                  pat_list: [{(mingw) (Lit_Star '*')}]
                  action: [
                    (command.Simple
                      words: [{(cat)}]
                      redirects: [
                        (redir.HereDoc
                          op: <Redir_DLess '<<'>
                          fd: 16777215
                          here_begin: {(DQ (EOF))}
                          here_end_span_id: 28298
                          stdin_parts: [
                            ("  /* execv doesn't actually work on mingw as expected on unix */\n")
                            ('  newargz = prepare_spawn (newargz);\n')
                            (
'  rval = (int) _spawnv (_P_WAIT, lt_argv_zero, (const char * const *) newargz);\n'
                            )
                            ('  if (rval == -1)\n')
                            ('    {\n')
                            ('      /* failed to start process */\n')
                            ('      lt_debugprintf (__FILE__, __LINE__,\n')
                            ('\t\t      "(main) failed to launch target \\"%s\\": %s\\n",\n')
                            ('\t\t      lt_argv_zero, nonnull (strerror (errno)));\n')
                            ('      return 127;\n')
                            ('    }\n')
                            ('  return rval;\n')
                          ]
                        )
                      ]
                    )
                  ]
                )
                (case_arm
                  pat_list: [{(Lit_Star '*')}]
                  action: [
                    (command.Simple
                      words: [{(cat)}]
                      redirects: [
                        (redir.HereDoc
                          op: <Redir_DLess '<<'>
                          fd: 16777215
                          here_begin: {(DQ (EOF))}
                          here_end_span_id: 28316
                          stdin_parts: [
                            ('  execv (lt_argv_zero, newargz);\n')
                            ('  return rval; /* =127, but avoids unused variable warning */\n')
                          ]
                        )
                      ]
                    )
                  ]
                )
              ]
            )
            (command.Simple
              words: [{(cat)}]
              redirects: [
                (redir.HereDoc
                  op: <Redir_DLess '<<'>
                  fd: 16777215
                  here_begin: {(DQ (EOF))}
                  here_end_span_id: 28724
                  stdin_parts: [
                    ('}\n')
                    ('\n')
                    ('void *\n')
                    ('xmalloc (size_t num)\n')
                    ('{\n')
                    ('  void *p = (void *) malloc (num);\n')
                    ('  if (!p)\n')
                    ('    lt_fatal (__FILE__, __LINE__, "memory exhausted");\n')
                    ('\n')
                    ('  return p;\n')
                    ('}\n')
                    ('\n')
                    ('char *\n')
                    ('xstrdup (const char *string)\n')
                    ('{\n')
                    ('  return string ? strcpy ((char *) xmalloc (strlen (string) + 1),\n')
                    ('\t\t\t  string) : NULL;\n')
                    ('}\n')
                    ('\n')
                    ('const char *\n')
                    ('base_name (const char *name)\n')
                    ('{\n')
                    ('  const char *base;\n')
                    ('\n')
                    ('#if defined HAVE_DOS_BASED_FILE_SYSTEM\n')
                    ('  /* Skip over the disk name in MSDOS pathnames. */\n')
                    ("  if (isalpha ((unsigned char) name[0]) && name[1] == ':')\n")
                    ('    name += 2;\n')
                    ('#endif\n')
                    ('\n')
                    ('  for (base = name; *name; name++)\n')
                    ('    if (IS_DIR_SEPARATOR (*name))\n')
                    ('      base = name + 1;\n')
                    ('  return base;\n')
                    ('}\n')
                    ('\n')
                    ('int\n')
                    ('check_executable (const char *path)\n')
                    ('{\n')
                    ('  struct stat st;\n')
                    ('\n')
                    ('  lt_debugprintf (__FILE__, __LINE__, "(check_executable): %s\\n",\n')
                    ('                  nonempty (path));\n')
                    ('  if ((!path) || (!*path))\n')
                    ('    return 0;\n')
                    ('\n')
                    ('  if ((stat (path, &st) >= 0)\n')
                    ('      && (st.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH)))\n')
                    ('    return 1;\n')
                    ('  else\n')
                    ('    return 0;\n')
                    ('}\n')
                    ('\n')
                    ('int\n')
                    ('make_executable (const char *path)\n')
                    ('{\n')
                    ('  int rval = 0;\n')
                    ('  struct stat st;\n')
                    ('\n')
                    ('  lt_debugprintf (__FILE__, __LINE__, "(make_executable): %s\\n",\n')
                    ('                  nonempty (path));\n')
                    ('  if ((!path) || (!*path))\n')
                    ('    return 0;\n')
                    ('\n')
                    ('  if (stat (path, &st) >= 0)\n')
                    ('    {\n')
                    ('      rval = chmod (path, st.st_mode | S_IXOTH | S_IXGRP | S_IXUSR);\n')
                    ('    }\n')
                    ('  return rval;\n')
                    ('}\n')
                    ('\n')
                    ('/* Searches for the full path of the wrapper.  Returns\n')
                    ('   newly allocated full path name if found, NULL otherwise\n')
                    ('   Does not chase symlinks, even on platforms that support them.\n')
                    ('*/\n')
                    ('char *\n')
                    ('find_executable (const char *wrapper)\n')
                    ('{\n')
                    ('  int has_slash = 0;\n')
                    ('  const char *p;\n')
                    ('  const char *p_next;\n')
                    ('  /* static buffer for getcwd */\n')
                    ('  char tmp[LT_PATHMAX + 1];\n')
                    ('  size_t tmp_len;\n')
                    ('  char *concat_name;\n')
                    ('\n')
                    ('  lt_debugprintf (__FILE__, __LINE__, "(find_executable): %s\\n",\n')
                    ('                  nonempty (wrapper));\n')
                    ('\n')
                    ("  if ((wrapper == NULL) || (*wrapper == '\\0'))\n")
                    ('    return NULL;\n')
                    ('\n')
                    ('  /* Absolute path? */\n')
                    ('#if defined HAVE_DOS_BASED_FILE_SYSTEM\n')
                    ("  if (isalpha ((unsigned char) wrapper[0]) && wrapper[1] == ':')\n")
                    ('    {\n')
                    ('      concat_name = xstrdup (wrapper);\n')
                    ('      if (check_executable (concat_name))\n')
                    ('\treturn concat_name;\n')
                    ('      XFREE (concat_name);\n')
                    ('    }\n')
                    ('  else\n')
                    ('    {\n')
                    ('#endif\n')
                    ('      if (IS_DIR_SEPARATOR (wrapper[0]))\n')
                    ('\t{\n')
                    ('\t  concat_name = xstrdup (wrapper);\n')
                    ('\t  if (check_executable (concat_name))\n')
                    ('\t    return concat_name;\n')
                    ('\t  XFREE (concat_name);\n')
                    ('\t}\n')
                    ('#if defined HAVE_DOS_BASED_FILE_SYSTEM\n')
                    ('    }\n')
                    ('#endif\n')
                    ('\n')
                    ('  for (p = wrapper; *p; p++)\n')
                    ("    if (*p == '/')\n")
                    ('      {\n')
                    ('\thas_slash = 1;\n')
                    ('\tbreak;\n')
                    ('      }\n')
                    ('  if (!has_slash)\n')
                    ('    {\n')
                    ('      /* no slashes; search PATH */\n')
                    ('      const char *path = getenv ("PATH");\n')
                    ('      if (path != NULL)\n')
                    ('\t{\n')
                    ('\t  for (p = path; *p; p = p_next)\n')
                    ('\t    {\n')
                    ('\t      const char *q;\n')
                    ('\t      size_t p_len;\n')
                    ('\t      for (q = p; *q; q++)\n')
                    ('\t\tif (IS_PATH_SEPARATOR (*q))\n')
                    ('\t\t  break;\n')
                    ('\t      p_len = (size_t) (q - p);\n')
                    ("\t      p_next = (*q == '\\0' ? q : q + 1);\n")
                    ('\t      if (p_len == 0)\n')
                    ('\t\t{\n')
                    ('\t\t  /* empty path: current directory */\n')
                    ('\t\t  if (getcwd (tmp, LT_PATHMAX) == NULL)\n')
                    ('\t\t    lt_fatal (__FILE__, __LINE__, "getcwd failed: %s",\n')
                    ('                              nonnull (strerror (errno)));\n')
                    ('\t\t  tmp_len = strlen (tmp);\n')
                    ('\t\t  concat_name =\n')
                    ('\t\t    XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);\n')
                    ('\t\t  memcpy (concat_name, tmp, tmp_len);\n')
                    ("\t\t  concat_name[tmp_len] = '/';\n")
                    ('\t\t  strcpy (concat_name + tmp_len + 1, wrapper);\n')
                    ('\t\t}\n')
                    ('\t      else\n')
                    ('\t\t{\n')
                    ('\t\t  concat_name =\n')
                    ('\t\t    XMALLOC (char, p_len + 1 + strlen (wrapper) + 1);\n')
                    ('\t\t  memcpy (concat_name, p, p_len);\n')
                    ("\t\t  concat_name[p_len] = '/';\n")
                    ('\t\t  strcpy (concat_name + p_len + 1, wrapper);\n')
                    ('\t\t}\n')
                    ('\t      if (check_executable (concat_name))\n')
                    ('\t\treturn concat_name;\n')
                    ('\t      XFREE (concat_name);\n')
                    ('\t    }\n')
                    ('\t}\n')
                    ('      /* not found in PATH; assume curdir */\n')
                    ('    }\n')
                    ('  /* Relative path | not found in path: prepend cwd */\n')
                    ('  if (getcwd (tmp, LT_PATHMAX) == NULL)\n')
                    ('    lt_fatal (__FILE__, __LINE__, "getcwd failed: %s",\n')
                    ('              nonnull (strerror (errno)));\n')
                    ('  tmp_len = strlen (tmp);\n')
                    ('  concat_name = XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);\n')
                    ('  memcpy (concat_name, tmp, tmp_len);\n')
                    ("  concat_name[tmp_len] = '/';\n")
                    ('  strcpy (concat_name + tmp_len + 1, wrapper);\n')
                    ('\n')
                    ('  if (check_executable (concat_name))\n')
                    ('    return concat_name;\n')
                    ('  XFREE (concat_name);\n')
                    ('  return NULL;\n')
                    ('}\n')
                    ('\n')
                    ('char *\n')
                    ('chase_symlinks (const char *pathspec)\n')
                    ('{\n')
                    ('#ifndef S_ISLNK\n')
                    ('  return xstrdup (pathspec);\n')
                    ('#else\n')
                    ('  char buf[LT_PATHMAX];\n')
                    ('  struct stat s;\n')
                    ('  char *tmp_pathspec = xstrdup (pathspec);\n')
                    ('  char *p;\n')
                    ('  int has_symlinks = 0;\n')
                    ('  while (strlen (tmp_pathspec) && !has_symlinks)\n')
                    ('    {\n')
                    ('      lt_debugprintf (__FILE__, __LINE__,\n')
                    ('\t\t      "checking path component for symlinks: %s\\n",\n')
                    ('\t\t      tmp_pathspec);\n')
                    ('      if (lstat (tmp_pathspec, &s) == 0)\n')
                    ('\t{\n')
                    ('\t  if (S_ISLNK (s.st_mode) != 0)\n')
                    ('\t    {\n')
                    ('\t      has_symlinks = 1;\n')
                    ('\t      break;\n')
                    ('\t    }\n')
                    ('\n')
                    ('\t  /* search backwards for last DIR_SEPARATOR */\n')
                    ('\t  p = tmp_pathspec + strlen (tmp_pathspec) - 1;\n')
                    ('\t  while ((p > tmp_pathspec) && (!IS_DIR_SEPARATOR (*p)))\n')
                    ('\t    p--;\n')
                    ('\t  if ((p == tmp_pathspec) && (!IS_DIR_SEPARATOR (*p)))\n')
                    ('\t    {\n')
                    ('\t      /* no more DIR_SEPARATORS left */\n')
                    ('\t      break;\n')
                    ('\t    }\n')
                    ("\t  *p = '\\0';\n")
                    ('\t}\n')
                    ('      else\n')
                    ('\t{\n')
                    ('\t  lt_fatal (__FILE__, __LINE__,\n')
                    ('\t\t    "error accessing file \\"%s\\": %s",\n')
                    ('\t\t    tmp_pathspec, nonnull (strerror (errno)));\n')
                    ('\t}\n')
                    ('    }\n')
                    ('  XFREE (tmp_pathspec);\n')
                    ('\n')
                    ('  if (!has_symlinks)\n')
                    ('    {\n')
                    ('      return xstrdup (pathspec);\n')
                    ('    }\n')
                    ('\n')
                    ('  tmp_pathspec = realpath (pathspec, buf);\n')
                    ('  if (tmp_pathspec == 0)\n')
                    ('    {\n')
                    ('      lt_fatal (__FILE__, __LINE__,\n')
                    ('\t\t"could not follow symlinks for %s", pathspec);\n')
                    ('    }\n')
                    ('  return xstrdup (tmp_pathspec);\n')
                    ('#endif\n')
                    ('}\n')
                    ('\n')
                    ('char *\n')
                    ('strendzap (char *str, const char *pat)\n')
                    ('{\n')
                    ('  size_t len, patlen;\n')
                    ('\n')
                    ('  assert (str != NULL);\n')
                    ('  assert (pat != NULL);\n')
                    ('\n')
                    ('  len = strlen (str);\n')
                    ('  patlen = strlen (pat);\n')
                    ('\n')
                    ('  if (patlen <= len)\n')
                    ('    {\n')
                    ('      str += len - patlen;\n')
                    ('      if (STREQ (str, pat))\n')
                    ("\t*str = '\\0';\n")
                    ('    }\n')
                    ('  return str;\n')
                    ('}\n')
                    ('\n')
                    ('void\n')
                    ('lt_debugprintf (const char *file, int line, const char *fmt, ...)\n')
                    ('{\n')
                    ('  va_list args;\n')
                    ('  if (lt_debug)\n')
                    ('    {\n')
                    ('      (void) fprintf (stderr, "%s:%s:%d: ", program_name, file, line);\n')
                    ('      va_start (args, fmt);\n')
                    ('      (void) vfprintf (stderr, fmt, args);\n')
                    ('      va_end (args);\n')
                    ('    }\n')
                    ('}\n')
                    ('\n')
                    ('static void\n')
                    ('lt_error_core (int exit_status, const char *file,\n')
                    ('\t       int line, const char *mode,\n')
                    ('\t       const char *message, va_list ap)\n')
                    ('{\n')
                    ('  fprintf (stderr, "%s:%s:%d: %s: ", program_name, file, line, mode);\n')
                    ('  vfprintf (stderr, message, ap);\n')
                    ('  fprintf (stderr, ".\\n");\n')
                    ('\n')
                    ('  if (exit_status >= 0)\n')
                    ('    exit (exit_status);\n')
                    ('}\n')
                    ('\n')
                    ('void\n')
                    ('lt_fatal (const char *file, int line, const char *message, ...)\n')
                    ('{\n')
                    ('  va_list ap;\n')
                    ('  va_start (ap, message);\n')
                    ('  lt_error_core (EXIT_FAILURE, file, line, "FATAL", message, ap);\n')
                    ('  va_end (ap);\n')
                    ('}\n')
                    ('\n')
                    ('static const char *\n')
                    ('nonnull (const char *s)\n')
                    ('{\n')
                    ('  return s ? s : "(null)";\n')
                    ('}\n')
                    ('\n')
                    ('static const char *\n')
                    ('nonempty (const char *s)\n')
                    ('{\n')
                    ('  return (s && !*s) ? "(empty)" : nonnull (s);\n')
                    ('}\n')
                    ('\n')
                    ('void\n')
                    ('lt_setenv (const char *name, const char *value)\n')
                    ('{\n')
                    ('  lt_debugprintf (__FILE__, __LINE__,\n')
                    ('\t\t  "(lt_setenv) setting \'%s\' to \'%s\'\\n",\n')
                    ('                  nonnull (name), nonnull (value));\n')
                    ('  {\n')
                    ('#ifdef HAVE_SETENV\n')
                    ('    /* always make a copy, for consistency with !HAVE_SETENV */\n')
                    ('    char *str = xstrdup (value);\n')
                    ('    setenv (name, str, 1);\n')
                    ('#else\n')
                    ('    size_t len = strlen (name) + 1 + strlen (value) + 1;\n')
                    ('    char *str = XMALLOC (char, len);\n')
                    ('    sprintf (str, "%s=%s", name, value);\n')
                    ('    if (putenv (str) != EXIT_SUCCESS)\n')
                    ('      {\n')
                    ('        XFREE (str);\n')
                    ('      }\n')
                    ('#endif\n')
                    ('  }\n')
                    ('}\n')
                    ('\n')
                    ('char *\n')
                    ('lt_extend_str (const char *orig_value, const char *add, int to_end)\n')
                    ('{\n')
                    ('  char *new_value;\n')
                    ('  if (orig_value && *orig_value)\n')
                    ('    {\n')
                    ('      size_t orig_value_len = strlen (orig_value);\n')
                    ('      size_t add_len = strlen (add);\n')
                    ('      new_value = XMALLOC (char, add_len + orig_value_len + 1);\n')
                    ('      if (to_end)\n')
                    ('        {\n')
                    ('          strcpy (new_value, orig_value);\n')
                    ('          strcpy (new_value + orig_value_len, add);\n')
                    ('        }\n')
                    ('      else\n')
                    ('        {\n')
                    ('          strcpy (new_value, add);\n')
                    ('          strcpy (new_value + add_len, orig_value);\n')
                    ('        }\n')
                    ('    }\n')
                    ('  else\n')
                    ('    {\n')
                    ('      new_value = xstrdup (add);\n')
                    ('    }\n')
                    ('  return new_value;\n')
                    ('}\n')
                    ('\n')
                    ('void\n')
                    ('lt_update_exe_path (const char *name, const char *value)\n')
                    ('{\n')
                    ('  lt_debugprintf (__FILE__, __LINE__,\n')
                    ('\t\t  "(lt_update_exe_path) modifying \'%s\' by prepending \'%s\'\\n",\n')
                    ('                  nonnull (name), nonnull (value));\n')
                    ('\n')
                    ('  if (name && *name && value && *value)\n')
                    ('    {\n')
                    ('      char *new_value = lt_extend_str (getenv (name), value, 0);\n')
                    ("      /* some systems can't cope with a ':'-terminated path #' */\n")
                    ('      size_t len = strlen (new_value);\n')
                    ('      while ((len > 0) && IS_PATH_SEPARATOR (new_value[len-1]))\n')
                    ('        {\n')
                    ("          new_value[--len] = '\\0';\n")
                    ('        }\n')
                    ('      lt_setenv (name, new_value);\n')
                    ('      XFREE (new_value);\n')
                    ('    }\n')
                    ('}\n')
                    ('\n')
                    ('void\n')
                    ('lt_update_lib_path (const char *name, const char *value)\n')
                    ('{\n')
                    ('  lt_debugprintf (__FILE__, __LINE__,\n')
                    ('\t\t  "(lt_update_lib_path) modifying \'%s\' by prepending \'%s\'\\n",\n')
                    ('                  nonnull (name), nonnull (value));\n')
                    ('\n')
                    ('  if (name && *name && value && *value)\n')
                    ('    {\n')
                    ('      char *new_value = lt_extend_str (getenv (name), value, 0);\n')
                    ('      lt_setenv (name, new_value);\n')
                    ('      XFREE (new_value);\n')
                    ('    }\n')
                    ('}\n')
                    ('\n')
                  ]
                )
              ]
            )
            (command.Case
              to_match: {($ VSub_DollarName '$host_os')}
              arms: [
                (case_arm
                  pat_list: [{(mingw) (Lit_Star '*')}]
                  action: [
                    (command.Simple
                      words: [{(cat)}]
                      redirects: [
                        (redir.HereDoc
                          op: <Redir_DLess '<<'>
                          fd: 16777215
                          here_begin: {(DQ (EOF))}
                          here_end_span_id: 28858
                          stdin_parts: [
                            ('\n')
                            ('/* Prepares an argument vector before calling spawn().\n')
                            (
'   Note that spawn() does not by itself call the command interpreter\n'
                            )
                            ('     (getenv ("COMSPEC") != NULL ? getenv ("COMSPEC") :\n')
                            (
'      ({ OSVERSIONINFO v; v.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);\n'
                            )
                            ('         GetVersionEx(&v);\n')
                            ('         v.dwPlatformId == VER_PLATFORM_WIN32_NT;\n')
                            ('      }) ? "cmd.exe" : "command.com").\n')
                            (
"   Instead it simply concatenates the arguments, separated by ' ', and calls\n"
                            )
                            (
'   CreateProcess().  We must quote the arguments since Win32 CreateProcess()\n'
                            )
                            (
'   interprets characters like \' \', \'\\t\', \'\\\\\', \'"\' (but not \'<\' and \'>\') in a\n'
                            )
                            ('   special way:\n')
                            (
'   - Space and tab are interpreted as delimiters. They are not treated as\n'
                            )
                            ('     delimiters if they are surrounded by double quotes: "...".\n')
                            (
'   - Unescaped double quotes are removed from the input. Their only effect is\n'
                            )
                            (
'     that within double quotes, space and tab are treated like normal\n'
                            )
                            ('     characters.\n')
                            ('   - Backslashes not followed by double quotes are not special.\n')
                            ('   - But 2*n+1 backslashes followed by a double quote become\n')
                            ('     n backslashes followed by a double quote (n >= 0):\n')
                            ('       \\" -> "\n')
                            ('       \\\\\\" -> \\"\n')
                            ('       \\\\\\\\\\" -> \\\\"\n')
                            (' */\n')
                            (
'#define SHELL_SPECIAL_CHARS "\\"\\\\ \\001\\002\\003\\004\\005\\006\\007\\010\\011\\012\\013\\014\\015\\016\\017\\020\\021\\022\\023\\024\\025\\026\\027\\030\\031\\032\\033\\034\\035\\036\\037"\n'
                            )
                            (
'#define SHELL_SPACE_CHARS " \\001\\002\\003\\004\\005\\006\\007\\010\\011\\012\\013\\014\\015\\016\\017\\020\\021\\022\\023\\024\\025\\026\\027\\030\\031\\032\\033\\034\\035\\036\\037"\n'
                            )
                            ('char **\n')
                            ('prepare_spawn (char **argv)\n')
                            ('{\n')
                            ('  size_t argc;\n')
                            ('  char **new_argv;\n')
                            ('  size_t i;\n')
                            ('\n')
                            ('  /* Count number of arguments.  */\n')
                            ('  for (argc = 0; argv[argc] != NULL; argc++)\n')
                            ('    ;\n')
                            ('\n')
                            ('  /* Allocate new argument vector.  */\n')
                            ('  new_argv = XMALLOC (char *, argc + 1);\n')
                            ('\n')
                            ('  /* Put quoted arguments into the new argument vector.  */\n')
                            ('  for (i = 0; i < argc; i++)\n')
                            ('    {\n')
                            ('      const char *string = argv[i];\n')
                            ('\n')
                            ("      if (string[0] == '\\0')\n")
                            ('\tnew_argv[i] = xstrdup ("\\"\\"");\n')
                            ('      else if (strpbrk (string, SHELL_SPECIAL_CHARS) != NULL)\n')
                            ('\t{\n')
                            (
'\t  int quote_around = (strpbrk (string, SHELL_SPACE_CHARS) != NULL);\n'
                            )
                            ('\t  size_t length;\n')
                            ('\t  unsigned int backslashes;\n')
                            ('\t  const char *s;\n')
                            ('\t  char *quoted_string;\n')
                            ('\t  char *p;\n')
                            ('\n')
                            ('\t  length = 0;\n')
                            ('\t  backslashes = 0;\n')
                            ('\t  if (quote_around)\n')
                            ('\t    length++;\n')
                            ("\t  for (s = string; *s != '\\0'; s++)\n")
                            ('\t    {\n')
                            ('\t      char c = *s;\n')
                            ('\t      if (c == \'"\')\n')
                            ('\t\tlength += backslashes + 1;\n')
                            ('\t      length++;\n')
                            ("\t      if (c == '\\\\')\n")
                            ('\t\tbackslashes++;\n')
                            ('\t      else\n')
                            ('\t\tbackslashes = 0;\n')
                            ('\t    }\n')
                            ('\t  if (quote_around)\n')
                            ('\t    length += backslashes + 1;\n')
                            ('\n')
                            ('\t  quoted_string = XMALLOC (char, length + 1);\n')
                            ('\n')
                            ('\t  p = quoted_string;\n')
                            ('\t  backslashes = 0;\n')
                            ('\t  if (quote_around)\n')
                            ('\t    *p++ = \'"\';\n')
                            ("\t  for (s = string; *s != '\\0'; s++)\n")
                            ('\t    {\n')
                            ('\t      char c = *s;\n')
                            ('\t      if (c == \'"\')\n')
                            ('\t\t{\n')
                            ('\t\t  unsigned int j;\n')
                            ('\t\t  for (j = backslashes + 1; j > 0; j--)\n')
                            ("\t\t    *p++ = '\\\\';\n")
                            ('\t\t}\n')
                            ('\t      *p++ = c;\n')
                            ("\t      if (c == '\\\\')\n")
                            ('\t\tbackslashes++;\n')
                            ('\t      else\n')
                            ('\t\tbackslashes = 0;\n')
                            ('\t    }\n')
                            ('\t  if (quote_around)\n')
                            ('\t    {\n')
                            ('\t      unsigned int j;\n')
                            ('\t      for (j = backslashes; j > 0; j--)\n')
                            ("\t\t*p++ = '\\\\';\n")
                            ('\t      *p++ = \'"\';\n')
                            ('\t    }\n')
                            ("\t  *p = '\\0';\n")
                            ('\n')
                            ('\t  new_argv[i] = quoted_string;\n')
                            ('\t}\n')
                            ('      else\n')
                            ('\tnew_argv[i] = (char *) string;\n')
                            ('    }\n')
                            ('  new_argv[argc] = NULL;\n')
                            ('\n')
                            ('  return new_argv;\n')
                            ('}\n')
                          ]
                        )
                      ]
                    )
                  ]
                )
              ]
            )
            (command.Simple
              words: [{(cat)}]
              redirects: [
                (redir.HereDoc
                  op: <Redir_DLess '<<'>
                  fd: 16777215
                  here_begin: {(DQ (EOF))}
                  here_end_span_id: 28876
                  stdin_parts: [('void lt_dump_script (FILE* f)\n') ('{\n')]
                )
              ]
            )
            (command.Pipeline
              children: [
                (C {(func_emit_wrapper)} {(yes)})
                (C {($ VSub_DollarName '$SED')} {(-n)} {(-e)} 
                  {
                    (SQ <'\n'> <'s/^\\(.\\{79\\}\\)\\(..*\\)/\\1\\\n'> <'\\2/\n'> <'h\n'> 
                      <'s/\\([\\\\"]\\)/\\\\\\1/g\n'> <'s/$/\\\\n/\n'> <'s/\\([^\\n]*\\).*/  fputs ("\\1", f);/p\n'> <'g\n'> <D>
                    )
                  }
                )
              ]
              negated: F
            )
            (command.Simple
              words: [{(cat)}]
              redirects: [
                (redir.HereDoc
                  op: <Redir_DLess '<<'>
                  fd: 16777215
                  here_begin: {(DQ (EOF))}
                  here_end_span_id: 28912
                  stdin_parts: [('}\n')]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: func_win32_import_lib_p
      body: 
        (command.BraceGroup
          children: [
            (C {($ VSub_DollarName '$debug_cmd')})
            (command.Case
              to_match: 
                {
                  (command_sub
                    left_token: <Left_Backtick '`'>
                    command_list: 
                      (command.CommandList
                        children: [
                          (command.Pipeline
                            children: [
                              (command.Simple
                                words: [
                                  {(eval)}
                                  {($ VSub_DollarName '$file_magic_cmd')}
                                  {(DQ ($ VSub_Number '$1'))}
                                ]
                                redirects: [
                                  (redir.Redir
                                    op: <Redir_Great '2>'>
                                    fd: 2
                                    arg_word: {(/dev/null)}
                                  )
                                ]
                              )
                              (C {($ VSub_DollarName '$SED')} {(-e)} {(10q)})
                            ]
                            negated: F
                          )
                        ]
                      )
                  )
                }
              arms: [
                (case_arm
                  pat_list: [{(Lit_Star '*') (import) (Lit_Star '*')}]
                  action: [(C {(Lit_Other ':')})]
                )
                (case_arm pat_list:[{(Lit_Star '*')}] action:[(C {(false)})])
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: func_suncc_cstd_abi
      body: 
        (command.BraceGroup
          children: [
            (C {($ VSub_DollarName '$debug_cmd')})
            (command.Case
              to_match: {(DQ (' ') ($ VSub_DollarName '$compile_command') (' '))}
              arms: [
                (case_arm
                  pat_list: [
                    {(Lit_Star '*') (DQ (' -compat=g ')) (Lit_Star '*')}
                    {(Lit_Star '*') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\ '>) (-std) 
                      (Lit_Equals '=') (c) (Lit_Other '+') (Lit_Other '+') (Lit_LBracket '[') (0-9) (Lit_RBracket ']') (Lit_LBracket '[') (0-9) 
                      (Lit_RBracket ']') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\ '>) (Lit_Star '*')
                    }
                    {(Lit_Star '*') (DQ (' -library=stdcxx4 ')) (Lit_Star '*')}
                    {(Lit_Star '*') (DQ (' -library=stlport4 ')) (Lit_Star '*')}
                  ]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:suncc_use_cstd_abi)
                          op: Equal
                          rhs: {(no)}
                        )
                      ]
                    )
                  ]
                )
                (case_arm
                  pat_list: [{(Lit_Star '*')}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:suncc_use_cstd_abi)
                          op: Equal
                          rhs: {(yes)}
                        )
                      ]
                    )
                  ]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: func_mode_link
      body: 
        (command.BraceGroup
          children: [
            (C {($ VSub_DollarName '$debug_cmd')})
            (command.Case
              to_match: {($ VSub_DollarName '$host')}
              arms: [
                (case_arm
                  pat_list: [
                    {(Lit_Star '*') (-) (Lit_Star '*') (-cygwin) (Lit_Star '*')}
                    {(Lit_Star '*') (-) (Lit_Star '*') (-mingw) (Lit_Star '*')}
                    {(Lit_Star '*') (-) (Lit_Star '*') (-pw32) (Lit_Star '*')}
                    {(Lit_Star '*') (-) (Lit_Star '*') (-os2) (Lit_Star '*')}
                    {(Lit_Star '*') (-cegcc) (Lit_Star '*')}
                  ]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:allow_undefined)
                          op: Equal
                          rhs: {(yes)}
                        )
                      ]
                    )
                  ]
                )
                (case_arm
                  pat_list: [{(Lit_Star '*')}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:allow_undefined)
                          op: Equal
                          rhs: {(yes)}
                        )
                      ]
                    )
                  ]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:libtool_args)
                  op: Equal
                  rhs: {($ VSub_DollarName '$nonopt')}
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:base_compile)
                  op: Equal
                  rhs: {(DQ ($ VSub_DollarName '$nonopt') (' ') ($ VSub_At '$@'))}
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:compile_command)
                  op: Equal
                  rhs: {($ VSub_DollarName '$nonopt')}
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:finalize_command)
                  op: Equal
                  rhs: {($ VSub_DollarName '$nonopt')}
                )
              ]
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:compile_rpath) op:Equal rhs:(word.Empty))]
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:finalize_rpath) op:Equal rhs:(word.Empty))]
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:compile_shlibpath) op:Equal rhs:(word.Empty))]
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:finalize_shlibpath) op:Equal rhs:(word.Empty))]
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:convenience) op:Equal rhs:(word.Empty))]
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:old_convenience) op:Equal rhs:(word.Empty))]
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:deplibs) op:Equal rhs:(word.Empty))]
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:old_deplibs) op:Equal rhs:(word.Empty))]
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:compiler_flags) op:Equal rhs:(word.Empty))]
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:linker_flags) op:Equal rhs:(word.Empty))]
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:dllsearchpath) op:Equal rhs:(word.Empty))]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:lib_search_path)
                  op: Equal
                  rhs: 
                    {
                      (command_sub
                        left_token: <Left_Backtick '`'>
                        command_list: (command.CommandList children:[(C {(pwd)})])
                      )
                    }
                )
              ]
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:inst_prefix_dir) op:Equal rhs:(word.Empty))]
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:new_inherited_linker_flags) op:Equal rhs:(word.Empty))]
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:avoid_version) op:Equal rhs:{(no)})]
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:bindir) op:Equal rhs:(word.Empty))]
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:dlfiles) op:Equal rhs:(word.Empty))]
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:dlprefiles) op:Equal rhs:(word.Empty))]
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:dlself) op:Equal rhs:{(no)})]
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:export_dynamic) op:Equal rhs:{(no)})]
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:export_symbols) op:Equal rhs:(word.Empty))]
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:export_symbols_regex) op:Equal rhs:(word.Empty))]
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:generated) op:Equal rhs:(word.Empty))]
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:libobjs) op:Equal rhs:(word.Empty))]
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:ltlibs) op:Equal rhs:(word.Empty))]
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:module) op:Equal rhs:{(no)})]
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:no_install) op:Equal rhs:{(no)})]
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:objs) op:Equal rhs:(word.Empty))]
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:os2dllname) op:Equal rhs:(word.Empty))]
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:non_pic_objects) op:Equal rhs:(word.Empty))]
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:precious_files_regex) op:Equal rhs:(word.Empty))]
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:prefer_static_libs) op:Equal rhs:{(no)})]
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:preload) op:Equal rhs:{(false)})]
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:prev) op:Equal rhs:(word.Empty))]
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:prevarg) op:Equal rhs:(word.Empty))]
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:release) op:Equal rhs:(word.Empty))]
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:rpath) op:Equal rhs:(word.Empty))]
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:xrpath) op:Equal rhs:(word.Empty))]
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:perm_rpath) op:Equal rhs:(word.Empty))]
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:temp_rpath) op:Equal rhs:(word.Empty))]
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:thread_safe) op:Equal rhs:{(no)})]
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:vinfo) op:Equal rhs:(word.Empty))]
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:vinfo_number) op:Equal rhs:{(no)})]
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:weak_libs) op:Equal rhs:(word.Empty))]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:single_module)
                  op: Equal
                  rhs: {($ VSub_DollarName '$wl') (-single_module)}
                )
              ]
            )
            (C {(func_infer_tag)} {($ VSub_DollarName '$base_compile')})
            (command.ForEach
              iter_name: arg
              do_arg_iter: T
              body: 
                (command.DoGroup
                  children: [
                    (command.Case
                      to_match: {($ VSub_DollarName '$arg')}
                      arms: [
                        (case_arm
                          pat_list: [{(-shared)}]
                          action: [
                            (command.AndOr
                              ops: [Op_DAmp]
                              children: [
                                (C {(test)} {(yes)} {(KW_Bang '!') (Lit_Equals '=')} 
                                  {(DQ ($ VSub_DollarName '$build_libtool_libs'))}
                                )
                                (C {(func_fatal_configuration)} {(DQ ('cannot build a shared library'))})
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:build_old_libs)
                                  op: Equal
                                  rhs: {(no)}
                                )
                              ]
                            )
                            (command.ControlFlow
                              token: <ControlFlow_Break break>
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(-all-static)} {(-static)} {(-static-libtool-libs)}]
                          action: [
                            (command.Case
                              to_match: {($ VSub_DollarName '$arg')}
                              arms: [
                                (case_arm
                                  pat_list: [{(-all-static)}]
                                  action: [
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (command.Sentence
                                              child: 
                                                (command.AndOr
                                                  ops: [Op_DAmp]
                                                  children: [
                                                    (C {(test)} {(yes)} {(Lit_Equals '=')} 
                                                      {(DQ ($ VSub_DollarName '$build_libtool_libs'))}
                                                    )
                                                    (C {(test)} {(-z)} 
                                                      {(DQ ($ VSub_DollarName '$link_static_flag'))}
                                                    )
                                                  ]
                                                )
                                              terminator: <Op_Semi ';'>
                                            )
                                          ]
                                          action: [
                                            (C {(func_warning)} 
                                              {
                                                (DQ 
                                                  (
'complete static linking is impossible in this configuration'
                                                  )
                                                )
                                              }
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (command.Sentence
                                              child: 
                                                (C {(test)} {(-n)} 
                                                  {(DQ ($ VSub_DollarName '$link_static_flag'))}
                                                )
                                              terminator: <Op_Semi ';'>
                                            )
                                          ]
                                          action: [
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:dlopen_self)
                                                  op: Equal
                                                  rhs: {($ VSub_DollarName '$dlopen_self_static')}
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:prefer_static_libs)
                                          op: Equal
                                          rhs: {(yes)}
                                        )
                                      ]
                                    )
                                  ]
                                )
                                (case_arm
                                  pat_list: [{(-static)}]
                                  action: [
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (command.Sentence
                                              child: 
                                                (command.AndOr
                                                  ops: [Op_DAmp]
                                                  children: [
                                                    (C {(test)} {(-z)} 
                                                      {(DQ ($ VSub_DollarName '$pic_flag'))}
                                                    )
                                                    (C {(test)} {(-n)} 
                                                      {(DQ ($ VSub_DollarName '$link_static_flag'))}
                                                    )
                                                  ]
                                                )
                                              terminator: <Op_Semi ';'>
                                            )
                                          ]
                                          action: [
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:dlopen_self)
                                                  op: Equal
                                                  rhs: {($ VSub_DollarName '$dlopen_self_static')}
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:prefer_static_libs)
                                          op: Equal
                                          rhs: {(built)}
                                        )
                                      ]
                                    )
                                  ]
                                )
                                (case_arm
                                  pat_list: [{(-static-libtool-libs)}]
                                  action: [
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (command.Sentence
                                              child: 
                                                (command.AndOr
                                                  ops: [Op_DAmp]
                                                  children: [
                                                    (C {(test)} {(-z)} 
                                                      {(DQ ($ VSub_DollarName '$pic_flag'))}
                                                    )
                                                    (C {(test)} {(-n)} 
                                                      {(DQ ($ VSub_DollarName '$link_static_flag'))}
                                                    )
                                                  ]
                                                )
                                              terminator: <Op_Semi ';'>
                                            )
                                          ]
                                          action: [
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:dlopen_self)
                                                  op: Equal
                                                  rhs: {($ VSub_DollarName '$dlopen_self_static')}
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:prefer_static_libs)
                                          op: Equal
                                          rhs: {(yes)}
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:build_libtool_libs)
                                  op: Equal
                                  rhs: {(no)}
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:build_old_libs)
                                  op: Equal
                                  rhs: {(yes)}
                                )
                              ]
                            )
                            (command.ControlFlow
                              token: <ControlFlow_Break break>
                            )
                          ]
                        )
                      ]
                    )
                  ]
                )
            )
            (command.AndOr
              ops: [Op_DAmp]
              children: [
                (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$old_archive_from_new_cmds'))})
                (command.ShAssignment
                  pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:build_old_libs) op:Equal rhs:{(yes)})]
                )
              ]
            )
            (command.WhileUntil
              keyword: <KW_While while>
              cond: [
                (command.Sentence
                  child: (C {(test)} {(DQ ($ VSub_Pound '$#'))} {(-gt)} {(0)})
                  terminator: <Op_Semi ';'>
                )
              ]
              body: 
                (command.DoGroup
                  children: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:arg)
                          op: Equal
                          rhs: {($ VSub_Number '$1')}
                        )
                      ]
                    )
                    (C {(shift)})
                    (C {(func_quote_for_eval)} {(DQ ($ VSub_DollarName '$arg'))})
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:qarg)
                          op: Equal
                          rhs: {($ VSub_DollarName '$func_quote_for_eval_unquoted_result')}
                        )
                      ]
                    )
                    (C {(func_append)} {(libtool_args)} 
                      {(DQ (' ') ($ VSub_DollarName '$func_quote_for_eval_result'))}
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$prev'))})
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [
                            (command.Case
                              to_match: {($ VSub_DollarName '$prev')}
                              arms: [
                                (case_arm
                                  pat_list: [{(output)}]
                                  action: [
                                    (C {(func_append)} {(compile_command)} {(DQ (' @OUTPUT@'))})
                                    (C {(func_append)} {(finalize_command)} {(DQ (' @OUTPUT@'))})
                                  ]
                                )
                              ]
                            )
                            (command.Case
                              to_match: {($ VSub_DollarName '$prev')}
                              arms: [
                                (case_arm
                                  pat_list: [{(bindir)}]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:bindir)
                                          op: Equal
                                          rhs: {($ VSub_DollarName '$arg')}
                                        )
                                      ]
                                    )
                                    (command.ShAssignment
                                      pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:prev) op:Equal rhs:(word.Empty))]
                                    )
                                    (command.ControlFlow
                                      token: <ControlFlow_Continue continue>
                                    )
                                  ]
                                )
                                (case_arm
                                  pat_list: [{(dlfiles)} {(dlprefiles)}]
                                  action: [
                                    (command.AndOr
                                      ops: [Op_DPipe]
                                      children: [
                                        (C {($ VSub_DollarName '$preload')})
                                        (command.BraceGroup
                                          children: [
                                            (C {(func_append)} {(compile_command)} {(DQ (' @SYMFILE@'))})
                                            (C {(func_append)} {(finalize_command)} {(DQ (' @SYMFILE@'))})
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:preload)
                                                  op: Equal
                                                  rhs: {(Lit_Other ':')}
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                    (command.Case
                                      to_match: {($ VSub_DollarName '$arg')}
                                      arms: [
                                        (case_arm
                                          pat_list: [{(Lit_Star '*') (.la)} {(Lit_Star '*') (.lo)}]
                                        )
                                        (case_arm
                                          pat_list: [{(force)}]
                                          action: [
                                            (command.If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (command.Sentence
                                                      child: 
                                                        (C {(test)} {(no)} {(Lit_Equals '=')} 
                                                          {(DQ ($ VSub_DollarName '$dlself'))}
                                                        )
                                                      terminator: <Op_Semi ';'>
                                                    )
                                                  ]
                                                  action: [
                                                    (command.ShAssignment
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (sh_lhs_expr.Name name:dlself)
                                                          op: Equal
                                                          rhs: {(needless)}
                                                        )
                                                      ]
                                                    )
                                                    (command.ShAssignment
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (sh_lhs_expr.Name name:export_dynamic)
                                                          op: Equal
                                                          rhs: {(yes)}
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                )
                                              ]
                                            )
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:prev)
                                                  op: Equal
                                                  rhs: (word.Empty)
                                                )
                                              ]
                                            )
                                            (command.ControlFlow
                                              token: <ControlFlow_Continue continue>
                                            )
                                          ]
                                        )
                                        (case_arm
                                          pat_list: [{(self)}]
                                          action: [
                                            (command.If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (command.Sentence
                                                      child: 
                                                        (C {(test)} {(dlprefiles)} {(Lit_Equals '=')} 
                                                          {(DQ ($ VSub_DollarName '$prev'))}
                                                        )
                                                      terminator: <Op_Semi ';'>
                                                    )
                                                  ]
                                                  action: [
                                                    (command.ShAssignment
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (sh_lhs_expr.Name name:dlself)
                                                          op: Equal
                                                          rhs: {(yes)}
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                )
                                                (if_arm
                                                  cond: [
                                                    (command.Sentence
                                                      child: 
                                                        (command.AndOr
                                                          ops: [Op_DAmp]
                                                          children: [
                                                            (C {(test)} {(dlfiles)} {(Lit_Equals '=')} 
                                                              {(DQ ($ VSub_DollarName '$prev'))}
                                                            )
                                                            (C {(test)} {(yes)} 
                                                              {(KW_Bang '!') (Lit_Equals '=')} {(DQ ($ VSub_DollarName '$dlopen_self'))}
                                                            )
                                                          ]
                                                        )
                                                      terminator: <Op_Semi ';'>
                                                    )
                                                  ]
                                                  action: [
                                                    (command.ShAssignment
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (sh_lhs_expr.Name name:dlself)
                                                          op: Equal
                                                          rhs: {(yes)}
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                )
                                              ]
                                              else_action: [
                                                (command.ShAssignment
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (sh_lhs_expr.Name name:dlself)
                                                      op: Equal
                                                      rhs: {(needless)}
                                                    )
                                                  ]
                                                )
                                                (command.ShAssignment
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (sh_lhs_expr.Name name:export_dynamic)
                                                      op: Equal
                                                      rhs: {(yes)}
                                                    )
                                                  ]
                                                )
                                              ]
                                            )
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:prev)
                                                  op: Equal
                                                  rhs: (word.Empty)
                                                )
                                              ]
                                            )
                                            (command.ControlFlow
                                              token: <ControlFlow_Continue continue>
                                            )
                                          ]
                                        )
                                        (case_arm
                                          pat_list: [{(Lit_Star '*')}]
                                          action: [
                                            (command.If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (command.Sentence
                                                      child: 
                                                        (C {(test)} {(dlfiles)} {(Lit_Equals '=')} 
                                                          {(DQ ($ VSub_DollarName '$prev'))}
                                                        )
                                                      terminator: <Op_Semi ';'>
                                                    )
                                                  ]
                                                  action: [
                                                    (C {(func_append)} {(dlfiles)} 
                                                      {(DQ (' ') ($ VSub_DollarName '$arg'))}
                                                    )
                                                  ]
                                                )
                                              ]
                                              else_action: [
                                                (C {(func_append)} {(dlprefiles)} 
                                                  {(DQ (' ') ($ VSub_DollarName '$arg'))}
                                                )
                                              ]
                                            )
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:prev)
                                                  op: Equal
                                                  rhs: (word.Empty)
                                                )
                                              ]
                                            )
                                            (command.ControlFlow
                                              token: <ControlFlow_Continue continue>
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                  ]
                                )
                                (case_arm
                                  pat_list: [{(expsyms)}]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:export_symbols)
                                          op: Equal
                                          rhs: {($ VSub_DollarName '$arg')}
                                        )
                                      ]
                                    )
                                    (command.AndOr
                                      ops: [Op_DPipe]
                                      children: [
                                        (C {(test)} {(-f)} {(DQ ($ VSub_DollarName '$arg'))})
                                        (C {(func_fatal_error)} 
                                          {
                                            (DQ ("symbol file '") ($ VSub_DollarName '$arg') 
                                              ("' does not exist")
                                            )
                                          }
                                        )
                                      ]
                                    )
                                    (command.ShAssignment
                                      pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:prev) op:Equal rhs:(word.Empty))]
                                    )
                                    (command.ControlFlow
                                      token: <ControlFlow_Continue continue>
                                    )
                                  ]
                                )
                                (case_arm
                                  pat_list: [{(expsyms_regex)}]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:export_symbols_regex)
                                          op: Equal
                                          rhs: {($ VSub_DollarName '$arg')}
                                        )
                                      ]
                                    )
                                    (command.ShAssignment
                                      pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:prev) op:Equal rhs:(word.Empty))]
                                    )
                                    (command.ControlFlow
                                      token: <ControlFlow_Continue continue>
                                    )
                                  ]
                                )
                                (case_arm
                                  pat_list: [{(framework)}]
                                  action: [
                                    (command.Case
                                      to_match: {($ VSub_DollarName '$host')}
                                      arms: [
                                        (case_arm
                                          pat_list: [
                                            {(Lit_Star '*') (-) (Lit_Star '*') (-darwin) (Lit_Star '*')}
                                          ]
                                          action: [
                                            (command.Case
                                              to_match: {(DQ ($ VSub_DollarName '$deplibs') (' '))}
                                              arms: [
                                                (case_arm
                                                  pat_list: [
                                                    {(Lit_Star '*') 
                                                      (DQ (' ') ($ VSub_DollarName '$qarg') 
                                                        ('.ltframework ')
                                                      ) (Lit_Star '*')
                                                    }
                                                  ]
                                                )
                                                (case_arm
                                                  pat_list: [{(Lit_Star '*')}]
                                                  action: [
                                                    (C {(func_append)} {(deplibs)} 
                                                      {
                                                        (DQ (' ') ($ VSub_DollarName '$qarg') 
                                                          (.ltframework)
                                                        )
                                                      }
                                                    )
                                                  ]
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                    (command.ShAssignment
                                      pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:prev) op:Equal rhs:(word.Empty))]
                                    )
                                    (command.ControlFlow
                                      token: <ControlFlow_Continue continue>
                                    )
                                  ]
                                )
                                (case_arm
                                  pat_list: [{(inst_prefix)}]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:inst_prefix_dir)
                                          op: Equal
                                          rhs: {($ VSub_DollarName '$arg')}
                                        )
                                      ]
                                    )
                                    (command.ShAssignment
                                      pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:prev) op:Equal rhs:(word.Empty))]
                                    )
                                    (command.ControlFlow
                                      token: <ControlFlow_Continue continue>
                                    )
                                  ]
                                )
                                (case_arm
                                  pat_list: [{(mllvm)}]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:prev) op:Equal rhs:(word.Empty))]
                                    )
                                    (command.ControlFlow
                                      token: <ControlFlow_Continue continue>
                                    )
                                  ]
                                )
                                (case_arm
                                  pat_list: [{(objectlist)}]
                                  action: [
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (command.Sentence
                                              child: 
                                                (C {(test)} {(-f)} {(DQ ($ VSub_DollarName '$arg'))})
                                              terminator: <Op_Semi ';'>
                                            )
                                          ]
                                          action: [
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:save_arg)
                                                  op: Equal
                                                  rhs: {($ VSub_DollarName '$arg')}
                                                )
                                              ]
                                            )
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:moreargs)
                                                  op: Equal
                                                  rhs: (word.Empty)
                                                )
                                              ]
                                            )
                                            (command.ForEach
                                              iter_name: fil
                                              iter_words: [
                                                {
                                                  (command_sub
                                                    left_token: <Left_Backtick '`'>
                                                    command_list: 
                                                      (command.CommandList
                                                        children: [
                                                          (C {(cat)} 
                                                            {(DQ ($ VSub_DollarName '$save_arg'))}
                                                          )
                                                        ]
                                                      )
                                                  )
                                                }
                                              ]
                                              do_arg_iter: F
                                              body: 
                                                (command.DoGroup
                                                  children: [
                                                    (command.ShAssignment
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (sh_lhs_expr.Name name:arg)
                                                          op: Equal
                                                          rhs: {($ VSub_DollarName '$fil')}
                                                        )
                                                      ]
                                                    )
                                                    (command.If
                                                      arms: [
                                                        (if_arm
                                                          cond: [
                                                            (command.Sentence
                                                              child: 
                                                                (C {(func_lalib_unsafe_p)} 
                                                                  {(DQ ($ VSub_DollarName '$arg'))}
                                                                )
                                                              terminator: <Op_Semi ';'>
                                                            )
                                                          ]
                                                          action: [
                                                            (command.ShAssignment
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: 
                                                                    (sh_lhs_expr.Name
                                                                      name: pic_object
                                                                    )
                                                                  op: Equal
                                                                  rhs: (word.Empty)
                                                                )
                                                              ]
                                                            )
                                                            (command.ShAssignment
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: 
                                                                    (sh_lhs_expr.Name
                                                                      name: non_pic_object
                                                                    )
                                                                  op: Equal
                                                                  rhs: (word.Empty)
                                                                )
                                                              ]
                                                            )
                                                            (C {(func_source)} 
                                                              {(DQ ($ VSub_DollarName '$arg'))}
                                                            )
                                                            (command.If
                                                              arms: [
                                                                (if_arm
                                                                  cond: [
                                                                    (command.Sentence
                                                                      child: 
                                                                        (command.AndOr
                                                                          ops: [
Op_DPipe
Op_DPipe
Op_DAmp
                                                                          ]
                                                                          children: [
                                                                            (C {(test)} {(-z)} 
                                                                              {
                                                                                (DQ 
                                                                                  ($ VSub_DollarName 
'$pic_object'
                                                                                  )
                                                                                )
                                                                              }
                                                                            )
                                                                            (C {(test)} {(-z)} 
                                                                              {
                                                                                (DQ 
                                                                                  ($ VSub_DollarName 
'$non_pic_object'
                                                                                  )
                                                                                )
                                                                              }
                                                                            )
                                                                            (C {(test)} {(none)} 
                                                                              {(Lit_Equals '=')} {(DQ ($ VSub_DollarName '$pic_object'))}
                                                                            )
                                                                            (C {(test)} {(none)} 
                                                                              {(Lit_Equals '=')} {(DQ ($ VSub_DollarName '$non_pic_object'))}
                                                                            )
                                                                          ]
                                                                        )
                                                                      terminator: <Op_Semi ';'>
                                                                    )
                                                                  ]
                                                                  action: [
                                                                    (C {(func_fatal_error)} 
                                                                      {
                                                                        (DQ 
                                                                          (
"cannot find name of object for '"
                                                                          ) ($ VSub_DollarName '$arg') ("'")
                                                                        )
                                                                      }
                                                                    )
                                                                  ]
                                                                )
                                                              ]
                                                            )
                                                            (C {(func_dirname)} 
                                                              {(DQ ($ VSub_DollarName '$arg'))} {(DQ (/))} {(DQ )}
                                                            )
                                                            (command.ShAssignment
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: (sh_lhs_expr.Name name:xdir)
                                                                  op: Equal
                                                                  rhs: 
                                                                    {
                                                                      ($ VSub_DollarName 
'$func_dirname_result'
                                                                      )
                                                                    }
                                                                )
                                                              ]
                                                            )
                                                            (command.If
                                                              arms: [
                                                                (if_arm
                                                                  cond: [
                                                                    (command.Sentence
                                                                      child: 
                                                                        (C {(test)} {(none)} 
                                                                          {(KW_Bang '!') 
                                                                            (Lit_Equals '=')
                                                                          } {(DQ ($ VSub_DollarName '$pic_object'))}
                                                                        )
                                                                      terminator: <Op_Semi ';'>
                                                                    )
                                                                  ]
                                                                  action: [
                                                                    (command.ShAssignment
                                                                      pairs: [
                                                                        (assign_pair
                                                                          lhs: 
                                                                            (sh_lhs_expr.Name
                                                                              name: pic_object
                                                                            )
                                                                          op: Equal
                                                                          rhs: 
                                                                            {
                                                                              ($ VSub_DollarName 
'$xdir'
                                                                              ) ($ VSub_DollarName '$pic_object')
                                                                            }
                                                                        )
                                                                      ]
                                                                    )
                                                                    (command.If
                                                                      arms: [
                                                                        (if_arm
                                                                          cond: [
                                                                            (command.Sentence
                                                                              child: 
                                                                                (C {(test)} {(dlfiles)} 
                                                                                  {(Lit_Equals '=')} {(DQ ($ VSub_DollarName '$prev'))}
                                                                                )
                                                                              terminator: 
                                                                                <Op_Semi ';'>
                                                                            )
                                                                          ]
                                                                          action: [
                                                                            (command.If
                                                                              arms: [
                                                                                (if_arm
                                                                                  cond: [
                                                                                    (command.Sentence
                                                                                      child: 
                                                                                        (command.AndOr
                                                                                          ops: [
Op_DAmp
                                                                                          ]
                                                                                          children: [
                                                                                            (C 
                                                                                              {
                                                                                                (
test
                                                                                                )
                                                                                              } {(yes)} {(Lit_Equals '=')} {(DQ ($ VSub_DollarName '$build_libtool_libs'))}
                                                                                            )
                                                                                            (C 
                                                                                              {
                                                                                                (
test
                                                                                                )
                                                                                              } {(yes)} {(Lit_Equals '=')} {(DQ ($ VSub_DollarName '$dlopen_support'))}
                                                                                            )
                                                                                          ]
                                                                                        )
                                                                                      terminator: 
                                                                                        <Op_Semi ';'>
                                                                                    )
                                                                                  ]
                                                                                  action: [
                                                                                    (C {(func_append)} 
                                                                                      {(dlfiles)} {(DQ (' ') ($ VSub_DollarName '$pic_object'))}
                                                                                    )
                                                                                    (command.ShAssignment
                                                                                      pairs: [
                                                                                        (assign_pair
                                                                                          lhs: 
                                                                                            (sh_lhs_expr.Name
                                                                                              name: 
prev
                                                                                            )
                                                                                          op: Equal
                                                                                          rhs: (word.Empty)
                                                                                        )
                                                                                      ]
                                                                                    )
                                                                                    (command.ControlFlow
                                                                                      token: 
                                                                                        <
ControlFlow_Continue continue
                                                                                        >
                                                                                    )
                                                                                  ]
                                                                                )
                                                                              ]
                                                                              else_action: [
                                                                                (command.ShAssignment
                                                                                  pairs: [
                                                                                    (assign_pair
                                                                                      lhs: 
                                                                                        (sh_lhs_expr.Name
                                                                                          name: prev
                                                                                        )
                                                                                      op: Equal
                                                                                      rhs: 
                                                                                        {
                                                                                          (
dlprefiles
                                                                                          )
                                                                                        }
                                                                                    )
                                                                                  ]
                                                                                )
                                                                              ]
                                                                            )
                                                                          ]
                                                                        )
                                                                      ]
                                                                    )
                                                                    (command.If
                                                                      arms: [
                                                                        (if_arm
                                                                          cond: [
                                                                            (command.Sentence
                                                                              child: 
                                                                                (C {(test)} 
                                                                                  {(dlprefiles)} {(Lit_Equals '=')} {(DQ ($ VSub_DollarName '$prev'))}
                                                                                )
                                                                              terminator: 
                                                                                <Op_Semi ';'>
                                                                            )
                                                                          ]
                                                                          action: [
                                                                            (C {(func_append)} 
                                                                              {(dlprefiles)} {(DQ (' ') ($ VSub_DollarName '$pic_object'))}
                                                                            )
                                                                            (command.ShAssignment
                                                                              pairs: [
                                                                                (assign_pair
                                                                                  lhs: 
                                                                                    (sh_lhs_expr.Name
                                                                                      name: prev
                                                                                    )
                                                                                  op: Equal
                                                                                  rhs: (word.Empty)
                                                                                )
                                                                              ]
                                                                            )
                                                                          ]
                                                                        )
                                                                      ]
                                                                    )
                                                                    (C {(func_append)} {(libobjs)} 
                                                                      {
                                                                        (DQ (' ') 
                                                                          ($ VSub_DollarName 
'$pic_object'
                                                                          )
                                                                        )
                                                                      }
                                                                    )
                                                                    (command.ShAssignment
                                                                      pairs: [
                                                                        (assign_pair
                                                                          lhs: 
                                                                            (sh_lhs_expr.Name
                                                                              name: arg
                                                                            )
                                                                          op: Equal
                                                                          rhs: 
                                                                            {
                                                                              ($ VSub_DollarName 
'$pic_object'
                                                                              )
                                                                            }
                                                                        )
                                                                      ]
                                                                    )
                                                                  ]
                                                                )
                                                              ]
                                                            )
                                                            (command.If
                                                              arms: [
                                                                (if_arm
                                                                  cond: [
                                                                    (command.Sentence
                                                                      child: 
                                                                        (C {(test)} {(none)} 
                                                                          {(KW_Bang '!') 
                                                                            (Lit_Equals '=')
                                                                          } {(DQ ($ VSub_DollarName '$non_pic_object'))}
                                                                        )
                                                                      terminator: <Op_Semi ';'>
                                                                    )
                                                                  ]
                                                                  action: [
                                                                    (command.ShAssignment
                                                                      pairs: [
                                                                        (assign_pair
                                                                          lhs: 
                                                                            (sh_lhs_expr.Name
                                                                              name: non_pic_object
                                                                            )
                                                                          op: Equal
                                                                          rhs: 
                                                                            {
                                                                              ($ VSub_DollarName 
'$xdir'
                                                                              ) ($ VSub_DollarName '$non_pic_object')
                                                                            }
                                                                        )
                                                                      ]
                                                                    )
                                                                    (C {(func_append)} 
                                                                      {(non_pic_objects)} {(DQ (' ') ($ VSub_DollarName '$non_pic_object'))}
                                                                    )
                                                                    (command.If
                                                                      arms: [
                                                                        (if_arm
                                                                          cond: [
                                                                            (command.Sentence
                                                                              child: 
                                                                                (command.AndOr
                                                                                  ops: [Op_DPipe]
                                                                                  children: [
                                                                                    (C {(test)} {(-z)} 
                                                                                      {
                                                                                        (DQ 
                                                                                          ($ 
VSub_DollarName '$pic_object'
                                                                                          )
                                                                                        )
                                                                                      }
                                                                                    )
                                                                                    (C {(test)} 
                                                                                      {(none)} {(Lit_Equals '=')} {(DQ ($ VSub_DollarName '$pic_object'))}
                                                                                    )
                                                                                  ]
                                                                                )
                                                                              terminator: 
                                                                                <Op_Semi ';'>
                                                                            )
                                                                          ]
                                                                          action: [
                                                                            (command.ShAssignment
                                                                              pairs: [
                                                                                (assign_pair
                                                                                  lhs: 
                                                                                    (sh_lhs_expr.Name
                                                                                      name: arg
                                                                                    )
                                                                                  op: Equal
                                                                                  rhs: 
                                                                                    {
                                                                                      ($ 
VSub_DollarName '$non_pic_object'
                                                                                      )
                                                                                    }
                                                                                )
                                                                              ]
                                                                            )
                                                                          ]
                                                                        )
                                                                      ]
                                                                    )
                                                                  ]
                                                                )
                                                              ]
                                                              else_action: [
                                                                (command.ShAssignment
                                                                  pairs: [
                                                                    (assign_pair
                                                                      lhs: 
                                                                        (sh_lhs_expr.Name
                                                                          name: non_pic_object
                                                                        )
                                                                      op: Equal
                                                                      rhs: 
                                                                        {
                                                                          ($ VSub_DollarName 
'$pic_object'
                                                                          )
                                                                        }
                                                                    )
                                                                  ]
                                                                )
                                                                (C {(func_append)} {(non_pic_objects)} 
                                                                  {
                                                                    (DQ (' ') 
                                                                      ($ VSub_DollarName 
'$non_pic_object'
                                                                      )
                                                                    )
                                                                  }
                                                                )
                                                              ]
                                                            )
                                                          ]
                                                        )
                                                      ]
                                                      else_action: [
                                                        (command.If
                                                          arms: [
                                                            (if_arm
                                                              cond: [
                                                                (command.Sentence
                                                                  child: 
                                                                    (C 
                                                                      {
                                                                        ($ VSub_DollarName 
'$opt_dry_run'
                                                                        )
                                                                      }
                                                                    )
                                                                  terminator: <Op_Semi ';'>
                                                                )
                                                              ]
                                                              action: [
                                                                (C {(func_dirname)} 
                                                                  {(DQ ($ VSub_DollarName '$arg'))} {(DQ (/))} {(DQ )}
                                                                )
                                                                (command.ShAssignment
                                                                  pairs: [
                                                                    (assign_pair
                                                                      lhs: 
                                                                        (sh_lhs_expr.Name
                                                                          name: xdir
                                                                        )
                                                                      op: Equal
                                                                      rhs: 
                                                                        {
                                                                          ($ VSub_DollarName 
'$func_dirname_result'
                                                                          )
                                                                        }
                                                                    )
                                                                  ]
                                                                )
                                                                (C {(func_lo2o)} 
                                                                  {(DQ ($ VSub_DollarName '$arg'))}
                                                                )
                                                                (command.ShAssignment
                                                                  pairs: [
                                                                    (assign_pair
                                                                      lhs: 
                                                                        (sh_lhs_expr.Name
                                                                          name: pic_object
                                                                        )
                                                                      op: Equal
                                                                      rhs: 
                                                                        {($ VSub_DollarName '$xdir') 
                                                                          ($ VSub_DollarName 
'$objdir'
                                                                          ) (/) ($ VSub_DollarName '$func_lo2o_result')
                                                                        }
                                                                    )
                                                                  ]
                                                                )
                                                                (command.ShAssignment
                                                                  pairs: [
                                                                    (assign_pair
                                                                      lhs: 
                                                                        (sh_lhs_expr.Name
                                                                          name: non_pic_object
                                                                        )
                                                                      op: Equal
                                                                      rhs: 
                                                                        {($ VSub_DollarName '$xdir') 
                                                                          ($ VSub_DollarName 
'$func_lo2o_result'
                                                                          )
                                                                        }
                                                                    )
                                                                  ]
                                                                )
                                                                (C {(func_append)} {(libobjs)} 
                                                                  {
                                                                    (DQ (' ') 
                                                                      ($ VSub_DollarName 
'$pic_object'
                                                                      )
                                                                    )
                                                                  }
                                                                )
                                                                (C {(func_append)} {(non_pic_objects)} 
                                                                  {
                                                                    (DQ (' ') 
                                                                      ($ VSub_DollarName 
'$non_pic_object'
                                                                      )
                                                                    )
                                                                  }
                                                                )
                                                              ]
                                                            )
                                                          ]
                                                          else_action: [
                                                            (C {(func_fatal_error)} 
                                                              {
                                                                (DQ ("'") ($ VSub_DollarName '$arg') 
                                                                  (
"' is not a valid libtool object"
                                                                  )
                                                                )
                                                              }
                                                            )
                                                          ]
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                )
                                            )
                                          ]
                                        )
                                      ]
                                      else_action: [
                                        (C {(func_fatal_error)} 
                                          {
                                            (DQ ("link input file '") ($ VSub_DollarName '$arg') 
                                              ("' does not exist")
                                            )
                                          }
                                        )
                                      ]
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:arg)
                                          op: Equal
                                          rhs: {($ VSub_DollarName '$save_arg')}
                                        )
                                      ]
                                    )
                                    (command.ShAssignment
                                      pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:prev) op:Equal rhs:(word.Empty))]
                                    )
                                    (command.ControlFlow
                                      token: <ControlFlow_Continue continue>
                                    )
                                  ]
                                )
                                (case_arm
                                  pat_list: [{(os2dllname)}]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:os2dllname)
                                          op: Equal
                                          rhs: {($ VSub_DollarName '$arg')}
                                        )
                                      ]
                                    )
                                    (command.ShAssignment
                                      pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:prev) op:Equal rhs:(word.Empty))]
                                    )
                                    (command.ControlFlow
                                      token: <ControlFlow_Continue continue>
                                    )
                                  ]
                                )
                                (case_arm
                                  pat_list: [{(precious_regex)}]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:precious_files_regex)
                                          op: Equal
                                          rhs: {($ VSub_DollarName '$arg')}
                                        )
                                      ]
                                    )
                                    (command.ShAssignment
                                      pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:prev) op:Equal rhs:(word.Empty))]
                                    )
                                    (command.ControlFlow
                                      token: <ControlFlow_Continue continue>
                                    )
                                  ]
                                )
                                (case_arm
                                  pat_list: [{(release)}]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:release)
                                          op: Equal
                                          rhs: {(-) ($ VSub_DollarName '$arg')}
                                        )
                                      ]
                                    )
                                    (command.ShAssignment
                                      pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:prev) op:Equal rhs:(word.Empty))]
                                    )
                                    (command.ControlFlow
                                      token: <ControlFlow_Continue continue>
                                    )
                                  ]
                                )
                                (case_arm
                                  pat_list: [{(rpath)} {(xrpath)}]
                                  action: [
                                    (command.Case
                                      to_match: {($ VSub_DollarName '$arg')}
                                      arms: [
                                        (case_arm
                                          pat_list: [
                                            {(Lit_LBracket '[') 
                                              (word_part.EscapedLiteral
                                                token: <Lit_EscapedChar '\\\\'>
                                              ) (/) (Lit_RBracket ']') (Lit_Star '*')
                                            }
                                            {(Lit_LBracket '[') (A-Za-z) (Lit_RBracket ']') 
                                              (Lit_Other ':') (Lit_LBracket '[') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\\\'>) (/) (Lit_RBracket ']') 
                                              (Lit_Star '*')
                                            }
                                          ]
                                        )
                                        (case_arm
                                          pat_list: [{(Lit_Star '*')}]
                                          action: [
                                            (C {(func_fatal_error)} 
                                              {(DQ ('only absolute run-paths are allowed'))}
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (command.Sentence
                                              child: 
                                                (C {(test)} {(rpath)} {(Lit_Equals '=')} 
                                                  {(DQ ($ VSub_DollarName '$prev'))}
                                                )
                                              terminator: <Op_Semi ';'>
                                            )
                                          ]
                                          action: [
                                            (command.Case
                                              to_match: {(DQ ($ VSub_DollarName '$rpath') (' '))}
                                              arms: [
                                                (case_arm
                                                  pat_list: [
                                                    {(Lit_Star '*') 
                                                      (DQ (' ') ($ VSub_DollarName '$arg') (' ')) (Lit_Star '*')
                                                    }
                                                  ]
                                                )
                                                (case_arm
                                                  pat_list: [{(Lit_Star '*')}]
                                                  action: [
                                                    (C {(func_append)} {(rpath)} 
                                                      {(DQ (' ') ($ VSub_DollarName '$arg'))}
                                                    )
                                                  ]
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                      ]
                                      else_action: [
                                        (command.Case
                                          to_match: {(DQ ($ VSub_DollarName '$xrpath') (' '))}
                                          arms: [
                                            (case_arm
                                              pat_list: [
                                                {(Lit_Star '*') 
                                                  (DQ (' ') ($ VSub_DollarName '$arg') (' ')) (Lit_Star '*')
                                                }
                                              ]
                                            )
                                            (case_arm
                                              pat_list: [{(Lit_Star '*')}]
                                              action: [
                                                (C {(func_append)} {(xrpath)} 
                                                  {(DQ (' ') ($ VSub_DollarName '$arg'))}
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                    (command.ShAssignment
                                      pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:prev) op:Equal rhs:(word.Empty))]
                                    )
                                    (command.ControlFlow
                                      token: <ControlFlow_Continue continue>
                                    )
                                  ]
                                )
                                (case_arm
                                  pat_list: [{(shrext)}]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:shrext_cmds)
                                          op: Equal
                                          rhs: {($ VSub_DollarName '$arg')}
                                        )
                                      ]
                                    )
                                    (command.ShAssignment
                                      pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:prev) op:Equal rhs:(word.Empty))]
                                    )
                                    (command.ControlFlow
                                      token: <ControlFlow_Continue continue>
                                    )
                                  ]
                                )
                                (case_arm
                                  pat_list: [{(weak)}]
                                  action: [
                                    (C {(func_append)} {(weak_libs)} 
                                      {(DQ (' ') ($ VSub_DollarName '$arg'))}
                                    )
                                    (command.ShAssignment
                                      pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:prev) op:Equal rhs:(word.Empty))]
                                    )
                                    (command.ControlFlow
                                      token: <ControlFlow_Continue continue>
                                    )
                                  ]
                                )
                                (case_arm
                                  pat_list: [{(xcclinker)}]
                                  action: [
                                    (C {(func_append)} {(linker_flags)} 
                                      {(DQ (' ') ($ VSub_DollarName '$qarg'))}
                                    )
                                    (C {(func_append)} {(compiler_flags)} 
                                      {(DQ (' ') ($ VSub_DollarName '$qarg'))}
                                    )
                                    (command.ShAssignment
                                      pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:prev) op:Equal rhs:(word.Empty))]
                                    )
                                    (C {(func_append)} {(compile_command)} 
                                      {(DQ (' ') ($ VSub_DollarName '$qarg'))}
                                    )
                                    (C {(func_append)} {(finalize_command)} 
                                      {(DQ (' ') ($ VSub_DollarName '$qarg'))}
                                    )
                                    (command.ControlFlow
                                      token: <ControlFlow_Continue continue>
                                    )
                                  ]
                                )
                                (case_arm
                                  pat_list: [{(xcompiler)}]
                                  action: [
                                    (C {(func_append)} {(compiler_flags)} 
                                      {(DQ (' ') ($ VSub_DollarName '$qarg'))}
                                    )
                                    (command.ShAssignment
                                      pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:prev) op:Equal rhs:(word.Empty))]
                                    )
                                    (C {(func_append)} {(compile_command)} 
                                      {(DQ (' ') ($ VSub_DollarName '$qarg'))}
                                    )
                                    (C {(func_append)} {(finalize_command)} 
                                      {(DQ (' ') ($ VSub_DollarName '$qarg'))}
                                    )
                                    (command.ControlFlow
                                      token: <ControlFlow_Continue continue>
                                    )
                                  ]
                                )
                                (case_arm
                                  pat_list: [{(xlinker)}]
                                  action: [
                                    (C {(func_append)} {(linker_flags)} 
                                      {(DQ (' ') ($ VSub_DollarName '$qarg'))}
                                    )
                                    (C {(func_append)} {(compiler_flags)} 
                                      {
                                        (DQ (' ') ($ VSub_DollarName '$wl') ($ VSub_DollarName '$qarg'))
                                      }
                                    )
                                    (command.ShAssignment
                                      pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:prev) op:Equal rhs:(word.Empty))]
                                    )
                                    (C {(func_append)} {(compile_command)} 
                                      {
                                        (DQ (' ') ($ VSub_DollarName '$wl') ($ VSub_DollarName '$qarg'))
                                      }
                                    )
                                    (C {(func_append)} {(finalize_command)} 
                                      {
                                        (DQ (' ') ($ VSub_DollarName '$wl') ($ VSub_DollarName '$qarg'))
                                      }
                                    )
                                    (command.ControlFlow
                                      token: <ControlFlow_Continue continue>
                                    )
                                  ]
                                )
                                (case_arm
                                  pat_list: [{(Lit_Star '*')}]
                                  action: [
                                    (C {(eval)} 
                                      {
                                        (DQ ($ VSub_DollarName '$prev') ('=') 
                                          (word_part.EscapedLiteral
                                            token: <Lit_EscapedChar '\\"'>
                                          ) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) (arg) 
                                          (word_part.EscapedLiteral
                                            token: <Lit_EscapedChar '\\"'>
                                          )
                                        )
                                      }
                                    )
                                    (command.ShAssignment
                                      pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:prev) op:Equal rhs:(word.Empty))]
                                    )
                                    (command.ControlFlow
                                      token: <ControlFlow_Continue continue>
                                    )
                                  ]
                                )
                              ]
                            )
                          ]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:prevarg)
                          op: Equal
                          rhs: {($ VSub_DollarName '$arg')}
                        )
                      ]
                    )
                    (command.Case
                      to_match: {($ VSub_DollarName '$arg')}
                      arms: [
                        (case_arm
                          pat_list: [{(-all-static)}]
                          action: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$link_static_flag'))})
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (C {(func_append)} {(compile_command)} 
                                      {(DQ (' ') ($ VSub_DollarName '$link_static_flag'))}
                                    )
                                    (C {(func_append)} {(finalize_command)} 
                                      {(DQ (' ') ($ VSub_DollarName '$link_static_flag'))}
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.ControlFlow
                              token: <ControlFlow_Continue continue>
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(-allow-undefined)}]
                          action: [
                            (C {(func_fatal_error)} 
                              {(DQ ("'-allow-undefined' must not be used because it is the default"))}
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(-avoid-version)}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:avoid_version)
                                  op: Equal
                                  rhs: {(yes)}
                                )
                              ]
                            )
                            (command.ControlFlow
                              token: <ControlFlow_Continue continue>
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(-bindir)}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:prev)
                                  op: Equal
                                  rhs: {(bindir)}
                                )
                              ]
                            )
                            (command.ControlFlow
                              token: <ControlFlow_Continue continue>
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(-dlopen)}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:prev)
                                  op: Equal
                                  rhs: {(dlfiles)}
                                )
                              ]
                            )
                            (command.ControlFlow
                              token: <ControlFlow_Continue continue>
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(-dlpreopen)}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:prev)
                                  op: Equal
                                  rhs: {(dlprefiles)}
                                )
                              ]
                            )
                            (command.ControlFlow
                              token: <ControlFlow_Continue continue>
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(-export-dynamic)}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:export_dynamic)
                                  op: Equal
                                  rhs: {(yes)}
                                )
                              ]
                            )
                            (command.ControlFlow
                              token: <ControlFlow_Continue continue>
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(-export-symbols)} {(-export-symbols-regex)}]
                          action: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (command.AndOr
                                          ops: [Op_DPipe]
                                          children: [
                                            (C {(test)} {(-n)} 
                                              {(DQ ($ VSub_DollarName '$export_symbols'))}
                                            )
                                            (C {(test)} {(-n)} 
                                              {(DQ ($ VSub_DollarName '$export_symbols_regex'))}
                                            )
                                          ]
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (C {(func_fatal_error)} 
                                      {
                                        (DQ 
                                          (
'more than one -exported-symbols argument is not allowed'
                                          )
                                        )
                                      }
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (C {(test)} {(X-export-symbols)} {(Lit_Equals '=')} 
                                          {(DQ (X) ($ VSub_DollarName '$arg'))}
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:prev)
                                          op: Equal
                                          rhs: {(expsyms)}
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                              else_action: [
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:prev)
                                      op: Equal
                                      rhs: {(expsyms_regex)}
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.ControlFlow
                              token: <ControlFlow_Continue continue>
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(-framework)}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:prev)
                                  op: Equal
                                  rhs: {(framework)}
                                )
                              ]
                            )
                            (command.ControlFlow
                              token: <ControlFlow_Continue continue>
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(-inst-prefix-dir)}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:prev)
                                  op: Equal
                                  rhs: {(inst_prefix)}
                                )
                              ]
                            )
                            (command.ControlFlow
                              token: <ControlFlow_Continue continue>
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [
                            {(-L) (Lit_LBracket '[') (A-Z) (Lit_RBracket ']') (Lit_LBracket '[') (A-Z) 
                              (Lit_RBracket ']') (Lit_Star '*') (Lit_Other ':') (Lit_Star '*')
                            }
                          ]
                          action: [
                            (command.Case
                              to_match: 
                                {($ VSub_DollarName '$with_gcc') (/) ($ VSub_DollarName '$host')}
                              arms: [
                                (case_arm
                                  pat_list: [
                                    {(no/) (Lit_Star '*') (-) (Lit_Star '*') (-irix) (Lit_Star '*')}
                                    {(/) (Lit_Star '*') (-) (Lit_Star '*') (-irix) (Lit_Star '*')}
                                  ]
                                  action: [
                                    (C {(func_append)} {(compile_command)} 
                                      {(DQ (' ') ($ VSub_DollarName '$arg'))}
                                    )
                                    (C {(func_append)} {(finalize_command)} 
                                      {(DQ (' ') ($ VSub_DollarName '$arg'))}
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.ControlFlow
                              token: <ControlFlow_Continue continue>
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(-L) (Lit_Star '*')}]
                          action: [
                            (C {(func_stripname)} {(DQ (-L))} {(SQ )} {(DQ ($ VSub_DollarName '$arg'))})
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (C {(test)} {(-z)} 
                                          {(DQ ($ VSub_DollarName '$func_stripname_result'))}
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (command.Sentence
                                              child: 
                                                (C {(test)} {(DQ ($ VSub_Pound '$#'))} {(-gt)} {(0)})
                                              terminator: <Op_Semi ';'>
                                            )
                                          ]
                                          action: [
                                            (C {(func_fatal_error)} 
                                              {
                                                (DQ ("require no space between '-L' and '") 
                                                  ($ VSub_Number '$1') ("'")
                                                )
                                              }
                                            )
                                          ]
                                        )
                                      ]
                                      else_action: [
                                        (C {(func_fatal_error)} {(DQ ("need path for '-L' option"))})
                                      ]
                                    )
                                  ]
                                )
                              ]
                            )
                            (C {(func_resolve_sysroot)} 
                              {(DQ ($ VSub_DollarName '$func_stripname_result'))}
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:dir)
                                  op: Equal
                                  rhs: {($ VSub_DollarName '$func_resolve_sysroot_result')}
                                )
                              ]
                            )
                            (command.Case
                              to_match: {($ VSub_DollarName '$dir')}
                              arms: [
                                (case_arm
                                  pat_list: [
                                    {(Lit_LBracket '[') 
                                      (word_part.EscapedLiteral
                                        token: <Lit_EscapedChar '\\\\'>
                                      ) (/) (Lit_RBracket ']') (Lit_Star '*')
                                    }
                                    {(Lit_LBracket '[') (A-Za-z) (Lit_RBracket ']') (Lit_Other ':') 
                                      (Lit_LBracket '[') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\\\'>) (/) (Lit_RBracket ']') (Lit_Star '*')
                                    }
                                  ]
                                )
                                (case_arm
                                  pat_list: [{(Lit_Star '*')}]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:absdir)
                                          op: Equal
                                          rhs: 
                                            {
                                              (command_sub
                                                left_token: <Left_Backtick '`'>
                                                command_list: 
                                                  (command.CommandList
                                                    children: [
                                                      (command.AndOr
                                                        ops: [Op_DAmp]
                                                        children: [
                                                          (C {(cd)} {(DQ ($ VSub_DollarName '$dir'))})
                                                          (C {(pwd)})
                                                        ]
                                                      )
                                                    ]
                                                  )
                                              )
                                            }
                                        )
                                      ]
                                    )
                                    (command.AndOr
                                      ops: [Op_DAmp]
                                      children: [
                                        (C {(test)} {(-z)} {(DQ ($ VSub_DollarName '$absdir'))})
                                        (C {(func_fatal_error)} 
                                          {
                                            (DQ ("cannot determine absolute directory name of '") 
                                              ($ VSub_DollarName '$dir') ("'")
                                            )
                                          }
                                        )
                                      ]
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:dir)
                                          op: Equal
                                          rhs: {($ VSub_DollarName '$absdir')}
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.Case
                              to_match: {(DQ ($ VSub_DollarName '$deplibs') (' '))}
                              arms: [
                                (case_arm
                                  pat_list: [
                                    {(Lit_Star '*') (DQ (' -L') ($ VSub_DollarName '$dir') (' ')) 
                                      (Lit_Star '*')
                                    }
                                    {(Lit_Star '*') (DQ (' ') ($ VSub_DollarName '$arg') (' ')) 
                                      (Lit_Star '*')
                                    }
                                  ]
                                )
                                (case_arm
                                  pat_list: [{(Lit_Star '*')}]
                                  action: [
                                    (command.Case
                                      to_match: {($ VSub_DollarName '$dir')}
                                      arms: [
                                        (case_arm
                                          pat_list: [
                                            {(Lit_LBracket '[') 
                                              (word_part.EscapedLiteral
                                                token: <Lit_EscapedChar '\\\\'>
                                              ) (/) (Lit_RBracket ']') (Lit_Star '*')
                                            }
                                            {(Lit_LBracket '[') (A-Za-z) (Lit_RBracket ']') 
                                              (Lit_Other ':') (Lit_LBracket '[') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\\\'>) (/) (Lit_RBracket ']') 
                                              (Lit_Star '*')
                                            }
                                            {(Lit_Equals '=') (Lit_Star '*')}
                                          ]
                                          action: [
                                            (C {(func_append)} {(deplibs)} 
                                              {(DQ (' ') ($ VSub_DollarName '$arg'))}
                                            )
                                          ]
                                        )
                                        (case_arm
                                          pat_list: [{(Lit_Star '*')}]
                                          action: [
                                            (C {(func_append)} {(deplibs)} 
                                              {(DQ (' -L') ($ VSub_DollarName '$dir'))}
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                    (C {(func_append)} {(lib_search_path)} 
                                      {(DQ (' ') ($ VSub_DollarName '$dir'))}
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.Case
                              to_match: {($ VSub_DollarName '$host')}
                              arms: [
                                (case_arm
                                  pat_list: [
                                    {(Lit_Star '*') (-) (Lit_Star '*') (-cygwin) (Lit_Star '*')}
                                    {(Lit_Star '*') (-) (Lit_Star '*') (-mingw) (Lit_Star '*')}
                                    {(Lit_Star '*') (-) (Lit_Star '*') (-pw32) (Lit_Star '*')}
                                    {(Lit_Star '*') (-) (Lit_Star '*') (-os2) (Lit_Star '*')}
                                    {(Lit_Star '*') (-cegcc) (Lit_Star '*')}
                                  ]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:testbindir)
                                          op: Equal
                                          rhs: 
                                            {
                                              (command_sub
                                                left_token: <Left_Backtick '`'>
                                                command_list: 
                                                  (command.CommandList
                                                    children: [
                                                      (command.Pipeline
                                                        children: [
                                                          (C {($ VSub_DollarName '$ECHO')} 
                                                            {(DQ ($ VSub_DollarName '$dir'))}
                                                          )
                                                          (C {($ VSub_DollarName '$SED')} 
                                                            {(SQ <'s*/lib$*/bin*'>)}
                                                          )
                                                        ]
                                                        negated: F
                                                      )
                                                    ]
                                                  )
                                              )
                                            }
                                        )
                                      ]
                                    )
                                    (command.Case
                                      to_match: 
                                        {(Lit_Other ':') ($ VSub_DollarName '$dllsearchpath') 
                                          (Lit_Other ':')
                                        }
                                      arms: [
                                        (case_arm
                                          pat_list: [
                                            {(Lit_Star '*') 
                                              (DQ (':') ($ VSub_DollarName '$dir') (':')) (Lit_Star '*')
                                            }
                                          ]
                                        )
                                        (case_arm
                                          pat_list: [{(Lit_Other ':') (Lit_Other ':')}]
                                          action: [
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:dllsearchpath)
                                                  op: Equal
                                                  rhs: {($ VSub_DollarName '$dir')}
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                        (case_arm
                                          pat_list: [{(Lit_Star '*')}]
                                          action: [
                                            (C {(func_append)} {(dllsearchpath)} 
                                              {(DQ (':') ($ VSub_DollarName '$dir'))}
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                    (command.Case
                                      to_match: 
                                        {(Lit_Other ':') ($ VSub_DollarName '$dllsearchpath') 
                                          (Lit_Other ':')
                                        }
                                      arms: [
                                        (case_arm
                                          pat_list: [
                                            {(Lit_Star '*') 
                                              (DQ (':') ($ VSub_DollarName '$testbindir') (':')) (Lit_Star '*')
                                            }
                                          ]
                                        )
                                        (case_arm
                                          pat_list: [{(Lit_Other ':') (Lit_Other ':')}]
                                          action: [
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:dllsearchpath)
                                                  op: Equal
                                                  rhs: {($ VSub_DollarName '$testbindir')}
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                        (case_arm
                                          pat_list: [{(Lit_Star '*')}]
                                          action: [
                                            (C {(func_append)} {(dllsearchpath)} 
                                              {(DQ (':') ($ VSub_DollarName '$testbindir'))}
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.ControlFlow
                              token: <ControlFlow_Continue continue>
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(-l) (Lit_Star '*')}]
                          action: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (command.AndOr
                                          ops: [Op_DPipe]
                                          children: [
                                            (C {(test)} {(X-lc)} {(Lit_Equals '=')} 
                                              {(DQ (X) ($ VSub_DollarName '$arg'))}
                                            )
                                            (C {(test)} {(X-lm)} {(Lit_Equals '=')} 
                                              {(DQ (X) ($ VSub_DollarName '$arg'))}
                                            )
                                          ]
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (command.Case
                                      to_match: {($ VSub_DollarName '$host')}
                                      arms: [
                                        (case_arm
                                          pat_list: [
                                            {(Lit_Star '*') (-) (Lit_Star '*') (-cygwin) (Lit_Star '*')}
                                            {(Lit_Star '*') (-) (Lit_Star '*') (-mingw) (Lit_Star '*')}
                                            {(Lit_Star '*') (-) (Lit_Star '*') (-pw32) (Lit_Star '*')}
                                            {(Lit_Star '*') (-) (Lit_Star '*') (-beos) (Lit_Star '*')}
                                            {(Lit_Star '*') (-cegcc) (Lit_Star '*')}
                                            {(Lit_Star '*') (-) (Lit_Star '*') (-haiku) (Lit_Star '*')}
                                          ]
                                          action: [
                                            (command.ControlFlow
                                              token: <ControlFlow_Continue continue>
                                            )
                                          ]
                                        )
                                        (case_arm
                                          pat_list: [
                                            {(Lit_Star '*') (-) (Lit_Star '*') (-os2) (Lit_Star '*')}
                                          ]
                                          action: [
                                            (command.AndOr
                                              ops: [Op_DAmp]
                                              children: [
                                                (C {(test)} {(X-lc)} {(Lit_Equals '=')} 
                                                  {(DQ (X) ($ VSub_DollarName '$arg'))}
                                                )
                                                (command.ControlFlow
                                                  token: <ControlFlow_Continue continue>
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                        (case_arm
                                          pat_list: [
                                            {(Lit_Star '*') (-) (Lit_Star '*') (-openbsd) (Lit_Star '*')}
                                            {(Lit_Star '*') (-) (Lit_Star '*') (-freebsd) (Lit_Star '*')}
                                            {(Lit_Star '*') (-) (Lit_Star '*') (-dragonfly) 
                                              (Lit_Star '*')
                                            }
                                            {(Lit_Star '*') (-) (Lit_Star '*') (-bitrig) (Lit_Star '*')}
                                          ]
                                          action: [
                                            (command.AndOr
                                              ops: [Op_DAmp]
                                              children: [
                                                (C {(test)} {(X-lc)} {(Lit_Equals '=')} 
                                                  {(DQ (X) ($ VSub_DollarName '$arg'))}
                                                )
                                                (command.ControlFlow
                                                  token: <ControlFlow_Continue continue>
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                        (case_arm
                                          pat_list: [
                                            {(Lit_Star '*') (-) (Lit_Star '*') (-rhapsody) 
                                              (Lit_Star '*')
                                            }
                                            {(Lit_Star '*') (-) (Lit_Star '*') (-darwin1.) 
                                              (Lit_LBracket '[') (012) (Lit_RBracket ']')
                                            }
                                          ]
                                          action: [
                                            (C {(func_append)} {(deplibs)} {(DQ (' System.ltframework'))})
                                            (command.ControlFlow
                                              token: <ControlFlow_Continue continue>
                                            )
                                          ]
                                        )
                                        (case_arm
                                          pat_list: [
                                            {(Lit_Star '*') (-) (Lit_Star '*') (-sco3.2v5) 
                                              (Lit_Star '*')
                                            }
                                            {(Lit_Star '*') (-) (Lit_Star '*') (-sco5v6) (Lit_Star '*')}
                                          ]
                                          action: [
                                            (command.AndOr
                                              ops: [Op_DAmp]
                                              children: [
                                                (C {(test)} {(X-lc)} {(Lit_Equals '=')} 
                                                  {(DQ (X) ($ VSub_DollarName '$arg'))}
                                                )
                                                (command.ControlFlow
                                                  token: <ControlFlow_Continue continue>
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                        (case_arm
                                          pat_list: [
                                            {(Lit_Star '*') (-) (Lit_Star '*') (-sysv4.2uw2) 
                                              (Lit_Star '*')
                                            }
                                            {(Lit_Star '*') (-) (Lit_Star '*') (-sysv5) (Lit_Star '*')}
                                            {(Lit_Star '*') (-) (Lit_Star '*') (-unixware) 
                                              (Lit_Star '*')
                                            }
                                            {(Lit_Star '*') (-) (Lit_Star '*') (-OpenUNIX) 
                                              (Lit_Star '*')
                                            }
                                          ]
                                          action: [
                                            (command.AndOr
                                              ops: [Op_DAmp]
                                              children: [
                                                (C {(test)} {(X-lc)} {(Lit_Equals '=')} 
                                                  {(DQ (X) ($ VSub_DollarName '$arg'))}
                                                )
                                                (command.ControlFlow
                                                  token: <ControlFlow_Continue continue>
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                  ]
                                )
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (C {(test)} {(X-lc_r)} {(Lit_Equals '=')} 
                                          {(DQ (X) ($ VSub_DollarName '$arg'))}
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (command.Case
                                      to_match: {($ VSub_DollarName '$host')}
                                      arms: [
                                        (case_arm
                                          pat_list: [
                                            {(Lit_Star '*') (-) (Lit_Star '*') (-openbsd) (Lit_Star '*')}
                                            {(Lit_Star '*') (-) (Lit_Star '*') (-freebsd) (Lit_Star '*')}
                                            {(Lit_Star '*') (-) (Lit_Star '*') (-dragonfly) 
                                              (Lit_Star '*')
                                            }
                                            {(Lit_Star '*') (-) (Lit_Star '*') (-bitrig) (Lit_Star '*')}
                                          ]
                                          action: [
                                            (command.ControlFlow
                                              token: <ControlFlow_Continue continue>
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                            )
                            (C {(func_append)} {(deplibs)} {(DQ (' ') ($ VSub_DollarName '$arg'))})
                            (command.ControlFlow
                              token: <ControlFlow_Continue continue>
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(-mllvm)}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:prev)
                                  op: Equal
                                  rhs: {(mllvm)}
                                )
                              ]
                            )
                            (command.ControlFlow
                              token: <ControlFlow_Continue continue>
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(-module)}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:module)
                                  op: Equal
                                  rhs: {(yes)}
                                )
                              ]
                            )
                            (command.ControlFlow
                              token: <ControlFlow_Continue continue>
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(-model)} {(-arch)} {(-isysroot)} {(--sysroot)}]
                          action: [
                            (C {(func_append)} {(compiler_flags)} {(DQ (' ') ($ VSub_DollarName '$arg'))})
                            (C {(func_append)} {(compile_command)} 
                              {(DQ (' ') ($ VSub_DollarName '$arg'))}
                            )
                            (C {(func_append)} {(finalize_command)} 
                              {(DQ (' ') ($ VSub_DollarName '$arg'))}
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:prev)
                                  op: Equal
                                  rhs: {(xcompiler)}
                                )
                              ]
                            )
                            (command.ControlFlow
                              token: <ControlFlow_Continue continue>
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [
                            {(-mt)}
                            {(-mthreads)}
                            {(-kthread)}
                            {(-Kthread)}
                            {(-pthread)}
                            {(-pthreads)}
                            {(--thread-safe)}
                            {(-threads)}
                            {(-fopenmp)}
                            {(-openmp)}
                            {(-mp)}
                            {(-xopenmp)}
                            {(-omp)}
                            {(-qsmp) (Lit_Equals '=') (Lit_Star '*')}
                          ]
                          action: [
                            (C {(func_append)} {(compiler_flags)} {(DQ (' ') ($ VSub_DollarName '$arg'))})
                            (C {(func_append)} {(compile_command)} 
                              {(DQ (' ') ($ VSub_DollarName '$arg'))}
                            )
                            (C {(func_append)} {(finalize_command)} 
                              {(DQ (' ') ($ VSub_DollarName '$arg'))}
                            )
                            (command.Case
                              to_match: {(DQ ($ VSub_DollarName '$new_inherited_linker_flags') (' '))}
                              arms: [
                                (case_arm
                                  pat_list: [
                                    {(Lit_Star '*') (DQ (' ') ($ VSub_DollarName '$arg') (' ')) 
                                      (Lit_Star '*')
                                    }
                                  ]
                                )
                                (case_arm
                                  pat_list: [{(Lit_Star '*')}]
                                  action: [
                                    (C {(func_append)} {(new_inherited_linker_flags)} 
                                      {(DQ (' ') ($ VSub_DollarName '$arg'))}
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.ControlFlow
                              token: <ControlFlow_Continue continue>
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(-multi_module)}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:single_module)
                                  op: Equal
                                  rhs: {($ VSub_DollarName '$wl') (-multi_module)}
                                )
                              ]
                            )
                            (command.ControlFlow
                              token: <ControlFlow_Continue continue>
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(-no-fast-install)}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:fast_install)
                                  op: Equal
                                  rhs: {(no)}
                                )
                              ]
                            )
                            (command.ControlFlow
                              token: <ControlFlow_Continue continue>
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(-no-install)}]
                          action: [
                            (command.Case
                              to_match: {($ VSub_DollarName '$host')}
                              arms: [
                                (case_arm
                                  pat_list: [
                                    {(Lit_Star '*') (-) (Lit_Star '*') (-cygwin) (Lit_Star '*')}
                                    {(Lit_Star '*') (-) (Lit_Star '*') (-mingw) (Lit_Star '*')}
                                    {(Lit_Star '*') (-) (Lit_Star '*') (-pw32) (Lit_Star '*')}
                                    {(Lit_Star '*') (-) (Lit_Star '*') (-os2) (Lit_Star '*')}
                                    {(Lit_Star '*') (-) (Lit_Star '*') (-darwin) (Lit_Star '*')}
                                    {(Lit_Star '*') (-cegcc) (Lit_Star '*')}
                                  ]
                                  action: [
                                    (C {(func_warning)} 
                                      {
                                        (DQ ("'-no-install' is ignored for ") 
                                          ($ VSub_DollarName '$host')
                                        )
                                      }
                                    )
                                    (C {(func_warning)} {(DQ ("assuming '-no-fast-install' instead"))})
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:fast_install)
                                          op: Equal
                                          rhs: {(no)}
                                        )
                                      ]
                                    )
                                  ]
                                )
                                (case_arm
                                  pat_list: [{(Lit_Star '*')}]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:no_install)
                                          op: Equal
                                          rhs: {(yes)}
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.ControlFlow
                              token: <ControlFlow_Continue continue>
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(-no-undefined)}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:allow_undefined)
                                  op: Equal
                                  rhs: {(no)}
                                )
                              ]
                            )
                            (command.ControlFlow
                              token: <ControlFlow_Continue continue>
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(-objectlist)}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:prev)
                                  op: Equal
                                  rhs: {(objectlist)}
                                )
                              ]
                            )
                            (command.ControlFlow
                              token: <ControlFlow_Continue continue>
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(-os2dllname)}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:prev)
                                  op: Equal
                                  rhs: {(os2dllname)}
                                )
                              ]
                            )
                            (command.ControlFlow
                              token: <ControlFlow_Continue continue>
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(-o)}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:prev)
                                  op: Equal
                                  rhs: {(output)}
                                )
                              ]
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(-precious-files-regex)}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:prev)
                                  op: Equal
                                  rhs: {(precious_regex)}
                                )
                              ]
                            )
                            (command.ControlFlow
                              token: <ControlFlow_Continue continue>
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(-release)}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:prev)
                                  op: Equal
                                  rhs: {(release)}
                                )
                              ]
                            )
                            (command.ControlFlow
                              token: <ControlFlow_Continue continue>
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(-rpath)}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:prev)
                                  op: Equal
                                  rhs: {(rpath)}
                                )
                              ]
                            )
                            (command.ControlFlow
                              token: <ControlFlow_Continue continue>
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(-R)}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:prev)
                                  op: Equal
                                  rhs: {(xrpath)}
                                )
                              ]
                            )
                            (command.ControlFlow
                              token: <ControlFlow_Continue continue>
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(-R) (Lit_Star '*')}]
                          action: [
                            (C {(func_stripname)} {(SQ <-R>)} {(SQ )} {(DQ ($ VSub_DollarName '$arg'))})
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:dir)
                                  op: Equal
                                  rhs: {($ VSub_DollarName '$func_stripname_result')}
                                )
                              ]
                            )
                            (command.Case
                              to_match: {($ VSub_DollarName '$dir')}
                              arms: [
                                (case_arm
                                  pat_list: [
                                    {(Lit_LBracket '[') 
                                      (word_part.EscapedLiteral
                                        token: <Lit_EscapedChar '\\\\'>
                                      ) (/) (Lit_RBracket ']') (Lit_Star '*')
                                    }
                                    {(Lit_LBracket '[') (A-Za-z) (Lit_RBracket ']') (Lit_Other ':') 
                                      (Lit_LBracket '[') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\\\'>) (/) (Lit_RBracket ']') (Lit_Star '*')
                                    }
                                  ]
                                )
                                (case_arm
                                  pat_list: [{(Lit_Equals '=') (Lit_Star '*')}]
                                  action: [
                                    (C {(func_stripname)} {(SQ <'='>)} {(SQ )} 
                                      {(DQ ($ VSub_DollarName '$dir'))}
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:dir)
                                          op: Equal
                                          rhs: 
                                            {($ VSub_DollarName '$lt_sysroot') 
                                              ($ VSub_DollarName '$func_stripname_result')
                                            }
                                        )
                                      ]
                                    )
                                  ]
                                )
                                (case_arm
                                  pat_list: [{(Lit_Star '*')}]
                                  action: [
                                    (C {(func_fatal_error)} 
                                      {(DQ ('only absolute run-paths are allowed'))}
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.Case
                              to_match: {(DQ ($ VSub_DollarName '$xrpath') (' '))}
                              arms: [
                                (case_arm
                                  pat_list: [
                                    {(Lit_Star '*') (DQ (' ') ($ VSub_DollarName '$dir') (' ')) 
                                      (Lit_Star '*')
                                    }
                                  ]
                                )
                                (case_arm
                                  pat_list: [{(Lit_Star '*')}]
                                  action: [
                                    (C {(func_append)} {(xrpath)} {(DQ (' ') ($ VSub_DollarName '$dir'))})
                                  ]
                                )
                              ]
                            )
                            (command.ControlFlow
                              token: <ControlFlow_Continue continue>
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(-shared)}]
                          action: [(command.ControlFlow token:<ControlFlow_Continue continue>)]
                        )
                        (case_arm
                          pat_list: [{(-shrext)}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:prev)
                                  op: Equal
                                  rhs: {(shrext)}
                                )
                              ]
                            )
                            (command.ControlFlow
                              token: <ControlFlow_Continue continue>
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(-static)} {(-static-libtool-libs)}]
                          action: [(command.ControlFlow token:<ControlFlow_Continue continue>)]
                        )
                        (case_arm
                          pat_list: [{(-thread-safe)}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:thread_safe)
                                  op: Equal
                                  rhs: {(yes)}
                                )
                              ]
                            )
                            (command.ControlFlow
                              token: <ControlFlow_Continue continue>
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(-version-info)}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:prev)
                                  op: Equal
                                  rhs: {(vinfo)}
                                )
                              ]
                            )
                            (command.ControlFlow
                              token: <ControlFlow_Continue continue>
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(-version-number)}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:prev)
                                  op: Equal
                                  rhs: {(vinfo)}
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:vinfo_number)
                                  op: Equal
                                  rhs: {(yes)}
                                )
                              ]
                            )
                            (command.ControlFlow
                              token: <ControlFlow_Continue continue>
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(-weak)}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:prev)
                                  op: Equal
                                  rhs: {(weak)}
                                )
                              ]
                            )
                            (command.ControlFlow
                              token: <ControlFlow_Continue continue>
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(-Wc) (Lit_Comma ',') (Lit_Star '*')}]
                          action: [
                            (C {(func_stripname)} {(SQ <'-Wc,'>)} {(SQ )} 
                              {(DQ ($ VSub_DollarName '$arg'))}
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:args)
                                  op: Equal
                                  rhs: {($ VSub_DollarName '$func_stripname_result')}
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:arg) op:Equal rhs:(word.Empty))]
                            )
                            (command.Sentence
                              child: 
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:save_ifs)
                                      op: Equal
                                      rhs: {($ VSub_DollarName '$IFS')}
                                    )
                                  ]
                                )
                              terminator: <Op_Semi ';'>
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:IFS)
                                  op: Equal
                                  rhs: {(Lit_Comma ',')}
                                )
                              ]
                            )
                            (command.ForEach
                              iter_name: flag
                              iter_words: [{($ VSub_DollarName '$args')}]
                              do_arg_iter: F
                              body: 
                                (command.DoGroup
                                  children: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:IFS)
                                          op: Equal
                                          rhs: {($ VSub_DollarName '$save_ifs')}
                                        )
                                      ]
                                    )
                                    (C {(func_quote_for_eval)} {(DQ ($ VSub_DollarName '$flag'))})
                                    (C {(func_append)} {(arg)} 
                                      {(DQ (' ') ($ VSub_DollarName '$func_quote_for_eval_result'))}
                                    )
                                    (C {(func_append)} {(compiler_flags)} 
                                      {(DQ (' ') ($ VSub_DollarName '$func_quote_for_eval_result'))}
                                    )
                                  ]
                                )
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:IFS)
                                  op: Equal
                                  rhs: {($ VSub_DollarName '$save_ifs')}
                                )
                              ]
                            )
                            (C {(func_stripname)} {(SQ <' '>)} {(SQ )} {(DQ ($ VSub_DollarName '$arg'))})
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:arg)
                                  op: Equal
                                  rhs: {($ VSub_DollarName '$func_stripname_result')}
                                )
                              ]
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(-Wl) (Lit_Comma ',') (Lit_Star '*')}]
                          action: [
                            (C {(func_stripname)} {(SQ <'-Wl,'>)} {(SQ )} 
                              {(DQ ($ VSub_DollarName '$arg'))}
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:args)
                                  op: Equal
                                  rhs: {($ VSub_DollarName '$func_stripname_result')}
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:arg) op:Equal rhs:(word.Empty))]
                            )
                            (command.Sentence
                              child: 
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:save_ifs)
                                      op: Equal
                                      rhs: {($ VSub_DollarName '$IFS')}
                                    )
                                  ]
                                )
                              terminator: <Op_Semi ';'>
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:IFS)
                                  op: Equal
                                  rhs: {(Lit_Comma ',')}
                                )
                              ]
                            )
                            (command.ForEach
                              iter_name: flag
                              iter_words: [{($ VSub_DollarName '$args')}]
                              do_arg_iter: F
                              body: 
                                (command.DoGroup
                                  children: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:IFS)
                                          op: Equal
                                          rhs: {($ VSub_DollarName '$save_ifs')}
                                        )
                                      ]
                                    )
                                    (C {(func_quote_for_eval)} {(DQ ($ VSub_DollarName '$flag'))})
                                    (C {(func_append)} {(arg)} 
                                      {
                                        (DQ (' ') ($ VSub_DollarName '$wl') 
                                          ($ VSub_DollarName '$func_quote_for_eval_result')
                                        )
                                      }
                                    )
                                    (C {(func_append)} {(compiler_flags)} 
                                      {
                                        (DQ (' ') ($ VSub_DollarName '$wl') 
                                          ($ VSub_DollarName '$func_quote_for_eval_result')
                                        )
                                      }
                                    )
                                    (C {(func_append)} {(linker_flags)} 
                                      {(DQ (' ') ($ VSub_DollarName '$func_quote_for_eval_result'))}
                                    )
                                  ]
                                )
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:IFS)
                                  op: Equal
                                  rhs: {($ VSub_DollarName '$save_ifs')}
                                )
                              ]
                            )
                            (C {(func_stripname)} {(SQ <' '>)} {(SQ )} {(DQ ($ VSub_DollarName '$arg'))})
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:arg)
                                  op: Equal
                                  rhs: {($ VSub_DollarName '$func_stripname_result')}
                                )
                              ]
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(-Xcompiler)}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:prev)
                                  op: Equal
                                  rhs: {(xcompiler)}
                                )
                              ]
                            )
                            (command.ControlFlow
                              token: <ControlFlow_Continue continue>
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(-Xlinker)}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:prev)
                                  op: Equal
                                  rhs: {(xlinker)}
                                )
                              ]
                            )
                            (command.ControlFlow
                              token: <ControlFlow_Continue continue>
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(-XCClinker)}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:prev)
                                  op: Equal
                                  rhs: {(xcclinker)}
                                )
                              ]
                            )
                            (command.ControlFlow
                              token: <ControlFlow_Continue continue>
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(-msg_) (Lit_Star '*')}]
                          action: [
                            (C {(func_quote_for_eval)} {(DQ ($ VSub_DollarName '$arg'))})
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:arg)
                                  op: Equal
                                  rhs: {($ VSub_DollarName '$func_quote_for_eval_result')}
                                )
                              ]
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [
                            {(-64)}
                            {(-mips) (Lit_LBracket '[') (0-9) (Lit_RBracket ']')}
                            {(-r) (Lit_LBracket '[') (0-9) (Lit_RBracket ']') (Lit_LBracket '[') (0-9) 
                              (Lit_RBracket ']') (Lit_Star '*')
                            }
                            {(-xarch) (Lit_Equals '=') (Lit_Star '*')}
                            {(-xtarget) (Lit_Equals '=') (Lit_Star '*')}
                            {(Lit_Other '+') (DA) (Lit_Star '*')}
                            {(Lit_Other '+') (DD) (Lit_Star '*')}
                            {(-q) (Lit_Star '*')}
                            {(-m) (Lit_Star '*')}
                            {(-t) (Lit_LBracket '[') (45) (Lit_RBracket ']') (Lit_Star '*')}
                            {(-txscale) (Lit_Star '*')}
                            {(-p)}
                            {(-pg)}
                            {(--coverage)}
                            {(-fprofile-) (Lit_Star '*')}
                            {(-F) (Lit_Star '*')}
                            {(Lit_Other '@') (Lit_Star '*')}
                            {(-tp) (Lit_Equals '=') (Lit_Star '*')}
                            {(--sysroot) (Lit_Equals '=') (Lit_Star '*')}
                            {(-O) (Lit_Star '*')}
                            {(-g) (Lit_Star '*')}
                            {(-flto) (Lit_Star '*')}
                            {(-fwhopr) (Lit_Star '*')}
                            {(-fuse-linker-plugin)}
                            {(-fstack-protector) (Lit_Star '*')}
                            {(-stdlib) (Lit_Equals '=') (Lit_Star '*')}
                            {(-specs) (Lit_Equals '=') (Lit_Star '*')}
                            {(-fsanitize) (Lit_Equals '=') (Lit_Star '*')}
                          ]
                          action: [
                            (C {(func_quote_for_eval)} {(DQ ($ VSub_DollarName '$arg'))})
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:arg)
                                  op: Equal
                                  rhs: {($ VSub_DollarName '$func_quote_for_eval_result')}
                                )
                              ]
                            )
                            (C {(func_append)} {(compile_command)} 
                              {(DQ (' ') ($ VSub_DollarName '$arg'))}
                            )
                            (C {(func_append)} {(finalize_command)} 
                              {(DQ (' ') ($ VSub_DollarName '$arg'))}
                            )
                            (C {(func_append)} {(compiler_flags)} {(DQ (' ') ($ VSub_DollarName '$arg'))})
                            (command.ControlFlow
                              token: <ControlFlow_Continue continue>
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(-Z) (Lit_Star '*')}]
                          action: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (C {(test)} {(os2)} {(Lit_Equals '=')} 
                                          {
                                            (DQ 
                                              (command_sub
                                                left_token: <Left_Backtick '`'>
                                                command_list: 
                                                  (command.CommandList
                                                    children: [
                                                      (C {(expr)} {($ VSub_DollarName '$host')} 
                                                        {(Lit_Other ':')} {(SQ <'.*\\(os2\\)'>)}
                                                      )
                                                    ]
                                                  )
                                              )
                                            )
                                          }
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:compiler_flags)
                                          op: Equal
                                          rhs: 
                                            {
                                              (DQ ($ VSub_DollarName '$compiler_flags') (' ') 
                                                ($ VSub_DollarName '$arg')
                                              )
                                            }
                                        )
                                      ]
                                    )
                                    (C {(func_append)} {(compile_command)} 
                                      {(DQ (' ') ($ VSub_DollarName '$arg'))}
                                    )
                                    (C {(func_append)} {(finalize_command)} 
                                      {(DQ (' ') ($ VSub_DollarName '$arg'))}
                                    )
                                    (command.Case
                                      to_match: {($ VSub_DollarName '$arg')}
                                      arms: [
                                        (case_arm
                                          pat_list: [{(-Zlinker)} {(-Zstack)}]
                                          action: [
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:prev)
                                                  op: Equal
                                                  rhs: {(xcompiler)}
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                    (command.ControlFlow
                                      token: <ControlFlow_Continue continue>
                                    )
                                  ]
                                )
                              ]
                              else_action: [
                                (C {(func_quote_for_eval)} {(DQ ($ VSub_DollarName '$arg'))})
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:arg)
                                      op: Equal
                                      rhs: {($ VSub_DollarName '$func_quote_for_eval_result')}
                                    )
                                  ]
                                )
                              ]
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(-) (Lit_Star '*')} {(Lit_Other '+') (Lit_Star '*')}]
                          action: [
                            (C {(func_quote_for_eval)} {(DQ ($ VSub_DollarName '$arg'))})
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:arg)
                                  op: Equal
                                  rhs: {($ VSub_DollarName '$func_quote_for_eval_result')}
                                )
                              ]
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(Lit_Star '*') (.) ($ VSub_DollarName '$objext')}]
                          action: [(C {(func_append)} {(objs)} {(DQ (' ') ($ VSub_DollarName '$arg'))})]
                        )
                        (case_arm
                          pat_list: [{(Lit_Star '*') (.lo)}]
                          action: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (C {(func_lalib_unsafe_p)} {(DQ ($ VSub_DollarName '$arg'))})
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:pic_object)
                                          op: Equal
                                          rhs: (word.Empty)
                                        )
                                      ]
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:non_pic_object)
                                          op: Equal
                                          rhs: (word.Empty)
                                        )
                                      ]
                                    )
                                    (C {(func_source)} {(DQ ($ VSub_DollarName '$arg'))})
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (command.Sentence
                                              child: 
                                                (command.AndOr
                                                  ops: [Op_DPipe Op_DPipe Op_DAmp]
                                                  children: [
                                                    (C {(test)} {(-z)} 
                                                      {(DQ ($ VSub_DollarName '$pic_object'))}
                                                    )
                                                    (C {(test)} {(-z)} 
                                                      {(DQ ($ VSub_DollarName '$non_pic_object'))}
                                                    )
                                                    (C {(test)} {(none)} {(Lit_Equals '=')} 
                                                      {(DQ ($ VSub_DollarName '$pic_object'))}
                                                    )
                                                    (C {(test)} {(none)} {(Lit_Equals '=')} 
                                                      {(DQ ($ VSub_DollarName '$non_pic_object'))}
                                                    )
                                                  ]
                                                )
                                              terminator: <Op_Semi ';'>
                                            )
                                          ]
                                          action: [
                                            (C {(func_fatal_error)} 
                                              {
                                                (DQ ("cannot find name of object for '") 
                                                  ($ VSub_DollarName '$arg') ("'")
                                                )
                                              }
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                    (C {(func_dirname)} {(DQ ($ VSub_DollarName '$arg'))} {(DQ (/))} {(DQ )})
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:xdir)
                                          op: Equal
                                          rhs: {($ VSub_DollarName '$func_dirname_result')}
                                        )
                                      ]
                                    )
                                    (command.AndOr
                                      ops: [Op_DPipe]
                                      children: [
                                        (C {(test)} {(none)} {(Lit_Equals '=')} 
                                          {(DQ ($ VSub_DollarName '$pic_object'))}
                                        )
                                        (command.BraceGroup
                                          children: [
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:pic_object)
                                                  op: Equal
                                                  rhs: 
                                                    {($ VSub_DollarName '$xdir') 
                                                      ($ VSub_DollarName '$pic_object')
                                                    }
                                                )
                                              ]
                                            )
                                            (command.If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (command.Sentence
                                                      child: 
                                                        (C {(test)} {(dlfiles)} {(Lit_Equals '=')} 
                                                          {(DQ ($ VSub_DollarName '$prev'))}
                                                        )
                                                      terminator: <Op_Semi ';'>
                                                    )
                                                  ]
                                                  action: [
                                                    (command.If
                                                      arms: [
                                                        (if_arm
                                                          cond: [
                                                            (command.Sentence
                                                              child: 
                                                                (command.AndOr
                                                                  ops: [Op_DAmp]
                                                                  children: [
                                                                    (C {(test)} {(yes)} 
                                                                      {(Lit_Equals '=')} {(DQ ($ VSub_DollarName '$build_libtool_libs'))}
                                                                    )
                                                                    (C {(test)} {(yes)} 
                                                                      {(Lit_Equals '=')} {(DQ ($ VSub_DollarName '$dlopen_support'))}
                                                                    )
                                                                  ]
                                                                )
                                                              terminator: <Op_Semi ';'>
                                                            )
                                                          ]
                                                          action: [
                                                            (C {(func_append)} {(dlfiles)} 
                                                              {
                                                                (DQ (' ') 
                                                                  ($ VSub_DollarName '$pic_object')
                                                                )
                                                              }
                                                            )
                                                            (command.ShAssignment
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: (sh_lhs_expr.Name name:prev)
                                                                  op: Equal
                                                                  rhs: (word.Empty)
                                                                )
                                                              ]
                                                            )
                                                            (command.ControlFlow
                                                              token: <ControlFlow_Continue continue>
                                                            )
                                                          ]
                                                        )
                                                      ]
                                                      else_action: [
                                                        (command.ShAssignment
                                                          pairs: [
                                                            (assign_pair
                                                              lhs: (sh_lhs_expr.Name name:prev)
                                                              op: Equal
                                                              rhs: {(dlprefiles)}
                                                            )
                                                          ]
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                )
                                              ]
                                            )
                                            (command.If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (command.Sentence
                                                      child: 
                                                        (C {(test)} {(dlprefiles)} {(Lit_Equals '=')} 
                                                          {(DQ ($ VSub_DollarName '$prev'))}
                                                        )
                                                      terminator: <Op_Semi ';'>
                                                    )
                                                  ]
                                                  action: [
                                                    (C {(func_append)} {(dlprefiles)} 
                                                      {(DQ (' ') ($ VSub_DollarName '$pic_object'))}
                                                    )
                                                    (command.ShAssignment
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (sh_lhs_expr.Name name:prev)
                                                          op: Equal
                                                          rhs: (word.Empty)
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                )
                                              ]
                                            )
                                            (C {(func_append)} {(libobjs)} 
                                              {(DQ (' ') ($ VSub_DollarName '$pic_object'))}
                                            )
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:arg)
                                                  op: Equal
                                                  rhs: {($ VSub_DollarName '$pic_object')}
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (command.Sentence
                                              child: 
                                                (C {(test)} {(none)} {(KW_Bang '!') (Lit_Equals '=')} 
                                                  {(DQ ($ VSub_DollarName '$non_pic_object'))}
                                                )
                                              terminator: <Op_Semi ';'>
                                            )
                                          ]
                                          action: [
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:non_pic_object)
                                                  op: Equal
                                                  rhs: 
                                                    {($ VSub_DollarName '$xdir') 
                                                      ($ VSub_DollarName '$non_pic_object')
                                                    }
                                                )
                                              ]
                                            )
                                            (C {(func_append)} {(non_pic_objects)} 
                                              {(DQ (' ') ($ VSub_DollarName '$non_pic_object'))}
                                            )
                                            (command.If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (command.Sentence
                                                      child: 
                                                        (command.AndOr
                                                          ops: [Op_DPipe]
                                                          children: [
                                                            (C {(test)} {(-z)} 
                                                              {(DQ ($ VSub_DollarName '$pic_object'))}
                                                            )
                                                            (C {(test)} {(none)} {(Lit_Equals '=')} 
                                                              {(DQ ($ VSub_DollarName '$pic_object'))}
                                                            )
                                                          ]
                                                        )
                                                      terminator: <Op_Semi ';'>
                                                    )
                                                  ]
                                                  action: [
                                                    (command.ShAssignment
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (sh_lhs_expr.Name name:arg)
                                                          op: Equal
                                                          rhs: {($ VSub_DollarName '$non_pic_object')}
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                      ]
                                      else_action: [
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:non_pic_object)
                                              op: Equal
                                              rhs: {($ VSub_DollarName '$pic_object')}
                                            )
                                          ]
                                        )
                                        (C {(func_append)} {(non_pic_objects)} 
                                          {(DQ (' ') ($ VSub_DollarName '$non_pic_object'))}
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                              else_action: [
                                (command.If
                                  arms: [
                                    (if_arm
                                      cond: [
                                        (command.Sentence
                                          child: (C {($ VSub_DollarName '$opt_dry_run')})
                                          terminator: <Op_Semi ';'>
                                        )
                                      ]
                                      action: [
                                        (C {(func_dirname)} {(DQ ($ VSub_DollarName '$arg'))} {(DQ (/))} {(DQ )})
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:xdir)
                                              op: Equal
                                              rhs: {($ VSub_DollarName '$func_dirname_result')}
                                            )
                                          ]
                                        )
                                        (C {(func_lo2o)} {(DQ ($ VSub_DollarName '$arg'))})
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:pic_object)
                                              op: Equal
                                              rhs: 
                                                {($ VSub_DollarName '$xdir') 
                                                  ($ VSub_DollarName '$objdir') (/) ($ VSub_DollarName '$func_lo2o_result')
                                                }
                                            )
                                          ]
                                        )
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:non_pic_object)
                                              op: Equal
                                              rhs: 
                                                {($ VSub_DollarName '$xdir') 
                                                  ($ VSub_DollarName '$func_lo2o_result')
                                                }
                                            )
                                          ]
                                        )
                                        (C {(func_append)} {(libobjs)} 
                                          {(DQ (' ') ($ VSub_DollarName '$pic_object'))}
                                        )
                                        (C {(func_append)} {(non_pic_objects)} 
                                          {(DQ (' ') ($ VSub_DollarName '$non_pic_object'))}
                                        )
                                      ]
                                    )
                                  ]
                                  else_action: [
                                    (C {(func_fatal_error)} 
                                      {
                                        (DQ ("'") ($ VSub_DollarName '$arg') 
                                          ("' is not a valid libtool object")
                                        )
                                      }
                                    )
                                  ]
                                )
                              ]
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(Lit_Star '*') (.) ($ VSub_DollarName '$libext')}]
                          action: [
                            (C {(func_append)} {(deplibs)} {(DQ (' ') ($ VSub_DollarName '$arg'))})
                            (C {(func_append)} {(old_deplibs)} {(DQ (' ') ($ VSub_DollarName '$arg'))})
                            (command.ControlFlow
                              token: <ControlFlow_Continue continue>
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(Lit_Star '*') (.la)}]
                          action: [
                            (C {(func_resolve_sysroot)} {(DQ ($ VSub_DollarName '$arg'))})
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (C {(test)} {(dlfiles)} {(Lit_Equals '=')} 
                                          {(DQ ($ VSub_DollarName '$prev'))}
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (C {(func_append)} {(dlfiles)} 
                                      {(DQ (' ') ($ VSub_DollarName '$func_resolve_sysroot_result'))}
                                    )
                                    (command.ShAssignment
                                      pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:prev) op:Equal rhs:(word.Empty))]
                                    )
                                  ]
                                )
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (C {(test)} {(dlprefiles)} {(Lit_Equals '=')} 
                                          {(DQ ($ VSub_DollarName '$prev'))}
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (C {(func_append)} {(dlprefiles)} 
                                      {(DQ (' ') ($ VSub_DollarName '$func_resolve_sysroot_result'))}
                                    )
                                    (command.ShAssignment
                                      pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:prev) op:Equal rhs:(word.Empty))]
                                    )
                                  ]
                                )
                              ]
                              else_action: [
                                (C {(func_append)} {(deplibs)} 
                                  {(DQ (' ') ($ VSub_DollarName '$func_resolve_sysroot_result'))}
                                )
                              ]
                            )
                            (command.ControlFlow
                              token: <ControlFlow_Continue continue>
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(Lit_Star '*')}]
                          action: [
                            (C {(func_quote_for_eval)} {(DQ ($ VSub_DollarName '$arg'))})
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:arg)
                                  op: Equal
                                  rhs: {($ VSub_DollarName '$func_quote_for_eval_result')}
                                )
                              ]
                            )
                          ]
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$arg'))})
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [
                            (C {(func_append)} {(compile_command)} 
                              {(DQ (' ') ($ VSub_DollarName '$arg'))}
                            )
                            (C {(func_append)} {(finalize_command)} 
                              {(DQ (' ') ($ VSub_DollarName '$arg'))}
                            )
                          ]
                        )
                      ]
                    )
                  ]
                )
            )
            (command.AndOr
              ops: [Op_DAmp]
              children: [
                (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$prev'))})
                (C {(func_fatal_help)} 
                  {(DQ ("the '") ($ VSub_DollarName '$prevarg') ("' option requires an argument"))}
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: 
                        (command.AndOr
                          ops: [Op_DAmp]
                          children: [
                            (C {(test)} {(yes)} {(Lit_Equals '=')} 
                              {(DQ ($ VSub_DollarName '$export_dynamic'))}
                            )
                            (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$export_dynamic_flag_spec'))})
                          ]
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (C {(eval)} 
                      {(Lit_VarLike 'arg=') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) 
                        ($ VSub_DollarName '$export_dynamic_flag_spec') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>)
                      }
                    )
                    (C {(func_append)} {(compile_command)} {(DQ (' ') ($ VSub_DollarName '$arg'))})
                    (C {(func_append)} {(finalize_command)} {(DQ (' ') ($ VSub_DollarName '$arg'))})
                  ]
                )
              ]
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:oldlibs) op:Equal rhs:(word.Empty))]
            )
            (C {(func_basename)} {(DQ ($ VSub_DollarName '$output'))})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:outputname)
                  op: Equal
                  rhs: {($ VSub_DollarName '$func_basename_result')}
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:libobjs_save)
                  op: Equal
                  rhs: {($ VSub_DollarName '$libobjs')}
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$shlibpath_var'))})
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (C {(eval)} 
                      {(Lit_VarLike 'shlib_search_path=') 
                        (word_part.EscapedLiteral
                          token: <Lit_EscapedChar '\\`'>
                        ) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) (ECHO)
                      } 
                      {(word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) 
                        (word_part.EscapedLiteral
                          token: <Lit_EscapedChar '\\$'>
                        ) ($ VSub_DollarName '$shlibpath_var') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>)
                      } {(word_part.EscapedLiteral token:<Lit_EscapedChar '\\|'>)} 
                      {(word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) (SED)} {(word_part.EscapedLiteral token:<Lit_EscapedChar "\\'">) (s/) (Lit_Other ':') (/)} 
                      {(/g) (word_part.EscapedLiteral token:<Lit_EscapedChar "\\'">) 
                        (word_part.EscapedLiteral
                          token: <Lit_EscapedChar '\\`'>
                        )
                      }
                    )
                  ]
                )
              ]
              else_action: [
                (command.ShAssignment
                  pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:shlib_search_path) op:Equal rhs:(word.Empty))]
                )
              ]
            )
            (C {(eval)} 
              {(Lit_VarLike 'sys_lib_search_path=') 
                (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) ($ VSub_DollarName '$sys_lib_search_path_spec') 
                (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>)
              }
            )
            (C {(eval)} 
              {(Lit_VarLike 'sys_lib_dlsearch_path=') 
                (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) ($ VSub_DollarName '$sys_lib_dlsearch_path_spec') 
                (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>)
              }
            )
            (C {(func_munge_path_list)} {(sys_lib_dlsearch_path)} 
              {(DQ ($ VSub_DollarName '$LT_SYS_LIBRARY_PATH'))}
            )
            (C {(func_dirname)} {(DQ ($ VSub_DollarName '$output'))} {(DQ (/))} {(DQ )})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:output_objdir)
                  op: Equal
                  rhs: {($ VSub_DollarName '$func_dirname_result') ($ VSub_DollarName '$objdir')}
                )
              ]
            )
            (C {(func_to_tool_file)} {(DQ ($ VSub_DollarName '$output_objdir') (/))})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:tool_output_objdir)
                  op: Equal
                  rhs: {($ VSub_DollarName '$func_to_tool_file_result')}
                )
              ]
            )
            (C {(func_mkdir_p)} {(DQ ($ VSub_DollarName '$output_objdir'))})
            (command.Case
              to_match: {($ VSub_DollarName '$output')}
              arms: [
                (case_arm
                  pat_list: [{(DQ )}]
                  action: [(C {(func_fatal_help)} {(DQ ('you must specify an output file'))})]
                )
                (case_arm
                  pat_list: [{(Lit_Star '*') (.) ($ VSub_DollarName '$libext')}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:linkmode)
                          op: Equal
                          rhs: {(oldlib)}
                        )
                      ]
                    )
                  ]
                )
                (case_arm
                  pat_list: [{(Lit_Star '*') (.lo)} {(Lit_Star '*') (.) ($ VSub_DollarName '$objext')}]
                  action: [
                    (command.ShAssignment
                      pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:linkmode) op:Equal rhs:{(obj)})]
                    )
                  ]
                )
                (case_arm
                  pat_list: [{(Lit_Star '*') (.la)}]
                  action: [
                    (command.ShAssignment
                      pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:linkmode) op:Equal rhs:{(lib)})]
                    )
                  ]
                )
                (case_arm
                  pat_list: [{(Lit_Star '*')}]
                  action: [
                    (command.ShAssignment
                      pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:linkmode) op:Equal rhs:{(prog)})]
                    )
                  ]
                )
              ]
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:specialdeplibs) op:Equal rhs:(word.Empty))]
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:libs) op:Equal rhs:(word.Empty))]
            )
            (command.ForEach
              iter_name: deplib
              iter_words: [{($ VSub_DollarName '$deplibs')}]
              do_arg_iter: F
              body: 
                (command.DoGroup
                  children: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: (C {($ VSub_DollarName '$opt_preserve_dup_deps')})
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [
                            (command.Case
                              to_match: {(DQ ($ VSub_DollarName '$libs') (' '))}
                              arms: [
                                (case_arm
                                  pat_list: [
                                    {(Lit_Star '*') (DQ (' ') ($ VSub_DollarName '$deplib') (' ')) 
                                      (Lit_Star '*')
                                    }
                                  ]
                                  action: [
                                    (C {(func_append)} {(specialdeplibs)} 
                                      {(DQ (' ') ($ VSub_DollarName '$deplib'))}
                                    )
                                  ]
                                )
                              ]
                            )
                          ]
                        )
                      ]
                    )
                    (C {(func_append)} {(libs)} {(DQ (' ') ($ VSub_DollarName '$deplib'))})
                  ]
                )
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: 
                        (C {(test)} {(lib)} {(Lit_Equals '=')} {(DQ ($ VSub_DollarName '$linkmode'))})
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:libs)
                          op: Equal
                          rhs: 
                            {
                              (DQ ($ VSub_DollarName '$predeps') (' ') ($ VSub_DollarName '$libs') (' ') 
                                ($ VSub_DollarName '$compiler_lib_search_path') (' ') ($ VSub_DollarName '$postdeps')
                              )
                            }
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:pre_post_deps) op:Equal rhs:(word.Empty))]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: (C {($ VSub_DollarName '$opt_duplicate_compiler_generated_deps')})
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [
                            (command.ForEach
                              iter_name: pre_post_dep
                              iter_words: [
                                {($ VSub_DollarName '$predeps')}
                                {($ VSub_DollarName '$postdeps')}
                              ]
                              do_arg_iter: F
                              body: 
                                (command.DoGroup
                                  children: [
                                    (command.Case
                                      to_match: {(DQ ($ VSub_DollarName '$pre_post_deps') (' '))}
                                      arms: [
                                        (case_arm
                                          pat_list: [
                                            {(Lit_Star '*') 
                                              (DQ (' ') ($ VSub_DollarName '$pre_post_dep') (' ')) (Lit_Star '*')
                                            }
                                          ]
                                          action: [
                                            (C {(func_append)} {(specialdeplibs)} 
                                              {(DQ (' ') ($ VSub_DollarName '$pre_post_deps'))}
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                    (C {(func_append)} {(pre_post_deps)} 
                                      {(DQ (' ') ($ VSub_DollarName '$pre_post_dep'))}
                                    )
                                  ]
                                )
                            )
                          ]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:pre_post_deps) op:Equal rhs:(word.Empty))]
                    )
                  ]
                )
              ]
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:deplibs) op:Equal rhs:(word.Empty))]
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:newdependency_libs) op:Equal rhs:(word.Empty))]
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:newlib_search_path) op:Equal rhs:(word.Empty))]
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:need_relink) op:Equal rhs:{(no)})]
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:notinst_deplibs) op:Equal rhs:(word.Empty))]
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:notinst_path) op:Equal rhs:(word.Empty))]
            )
            (command.Case
              to_match: {($ VSub_DollarName '$linkmode')}
              arms: [
                (case_arm
                  pat_list: [{(lib)}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:passes)
                          op: Equal
                          rhs: {(DQ ('conv dlpreopen link'))}
                        )
                      ]
                    )
                    (command.ForEach
                      iter_name: file
                      iter_words: [{($ VSub_DollarName '$dlfiles')} {($ VSub_DollarName '$dlprefiles')}]
                      do_arg_iter: F
                      body: 
                        (command.DoGroup
                          children: [
                            (command.Case
                              to_match: {($ VSub_DollarName '$file')}
                              arms: [
                                (case_arm
                                  pat_list: [{(Lit_Star '*') (.la)}]
                                )
                                (case_arm
                                  pat_list: [{(Lit_Star '*')}]
                                  action: [
                                    (C {(func_fatal_help)} 
                                      {
                                        (DQ ("libraries can '-dlopen' only libtool libraries: ") 
                                          ($ VSub_DollarName '$file')
                                        )
                                      }
                                    )
                                  ]
                                )
                              ]
                            )
                          ]
                        )
                    )
                  ]
                )
                (case_arm
                  pat_list: [{(prog)}]
                  action: [
                    (command.ShAssignment
                      pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:compile_deplibs) op:Equal rhs:(word.Empty))]
                    )
                    (command.ShAssignment
                      pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:finalize_deplibs) op:Equal rhs:(word.Empty))]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:alldeplibs)
                          op: Equal
                          rhs: {(false)}
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:newdlfiles) op:Equal rhs:(word.Empty))]
                    )
                    (command.ShAssignment
                      pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:newdlprefiles) op:Equal rhs:(word.Empty))]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:passes)
                          op: Equal
                          rhs: {(DQ ('conv scan dlopen dlpreopen link'))}
                        )
                      ]
                    )
                  ]
                )
                (case_arm
                  pat_list: [{(Lit_Star '*')}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:passes)
                          op: Equal
                          rhs: {(DQ (conv))}
                        )
                      ]
                    )
                  ]
                )
              ]
            )
            (command.ForEach
              iter_name: pass
              iter_words: [{($ VSub_DollarName '$passes')}]
              do_arg_iter: F
              body: 
                (command.DoGroup
                  children: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: 
                                (C {(test)} {(lib) (Lit_Comma ',') (link)} {(Lit_Equals '=')} 
                                  {
                                    (DQ ($ VSub_DollarName '$linkmode') (',') 
                                      ($ VSub_DollarName '$pass')
                                    )
                                  }
                                )
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [
                            (command.ShAssignment
                              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:tmp_deplibs) op:Equal rhs:(word.Empty))]
                            )
                            (command.ForEach
                              iter_name: deplib
                              iter_words: [{($ VSub_DollarName '$deplibs')}]
                              do_arg_iter: F
                              body: 
                                (command.DoGroup
                                  children: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:tmp_deplibs)
                                          op: Equal
                                          rhs: 
                                            {
                                              (DQ ($ VSub_DollarName '$deplib') (' ') 
                                                ($ VSub_DollarName '$tmp_deplibs')
                                              )
                                            }
                                        )
                                      ]
                                    )
                                  ]
                                )
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:deplibs)
                                  op: Equal
                                  rhs: {($ VSub_DollarName '$tmp_deplibs')}
                                )
                              ]
                            )
                          ]
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: 
                                (command.AndOr
                                  ops: [Op_DPipe]
                                  children: [
                                    (C {(test)} {(lib) (Lit_Comma ',') (link)} {(Lit_Equals '=')} 
                                      {
                                        (DQ ($ VSub_DollarName '$linkmode') (',') 
                                          ($ VSub_DollarName '$pass')
                                        )
                                      }
                                    )
                                    (C {(test)} {(prog) (Lit_Comma ',') (scan)} {(Lit_Equals '=')} 
                                      {
                                        (DQ ($ VSub_DollarName '$linkmode') (',') 
                                          ($ VSub_DollarName '$pass')
                                        )
                                      }
                                    )
                                  ]
                                )
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:libs)
                                  op: Equal
                                  rhs: {($ VSub_DollarName '$deplibs')}
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:deplibs) op:Equal rhs:(word.Empty))]
                            )
                          ]
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: 
                                (C {(test)} {(prog)} {(Lit_Equals '=')} 
                                  {(DQ ($ VSub_DollarName '$linkmode'))}
                                )
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [
                            (command.Case
                              to_match: {($ VSub_DollarName '$pass')}
                              arms: [
                                (case_arm
                                  pat_list: [{(dlopen)}]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:libs)
                                          op: Equal
                                          rhs: {($ VSub_DollarName '$dlfiles')}
                                        )
                                      ]
                                    )
                                  ]
                                )
                                (case_arm
                                  pat_list: [{(dlpreopen)}]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:libs)
                                          op: Equal
                                          rhs: {($ VSub_DollarName '$dlprefiles')}
                                        )
                                      ]
                                    )
                                  ]
                                )
                                (case_arm
                                  pat_list: [{(link)}]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:libs)
                                          op: Equal
                                          rhs: {(DQ ($ VSub_DollarName '$deplibs') (' %DEPLIBS%'))}
                                        )
                                      ]
                                    )
                                    (command.AndOr
                                      ops: [Op_DAmp]
                                      children: [
                                        (C {(test)} {(DQ (X) ($ VSub_DollarName '$link_all_deplibs'))} 
                                          {(KW_Bang '!') (Lit_Equals '=')} {(Xno)}
                                        )
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:libs)
                                              op: Equal
                                              rhs: 
                                                {
                                                  (DQ ($ VSub_DollarName '$libs') (' ') 
                                                    ($ VSub_DollarName '$dependency_libs')
                                                  )
                                                }
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                            )
                          ]
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: 
                                (C {(test)} {(lib) (Lit_Comma ',') (dlpreopen)} {(Lit_Equals '=')} 
                                  {
                                    (DQ ($ VSub_DollarName '$linkmode') (',') 
                                      ($ VSub_DollarName '$pass')
                                    )
                                  }
                                )
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [
                            (command.ForEach
                              iter_name: lib
                              iter_words: [{($ VSub_DollarName '$dlprefiles')}]
                              do_arg_iter: F
                              body: 
                                (command.DoGroup
                                  children: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:dependency_libs)
                                          op: Equal
                                          rhs: (word.Empty)
                                        )
                                      ]
                                    )
                                    (C {(func_resolve_sysroot)} {(DQ ($ VSub_DollarName '$lib'))})
                                    (command.Case
                                      to_match: {($ VSub_DollarName '$lib')}
                                      arms: [
                                        (case_arm
                                          pat_list: [{(Lit_Star '*') (.la)}]
                                          action: [
                                            (C {(func_source)} 
                                              {
                                                (DQ 
                                                  ($ VSub_DollarName '$func_resolve_sysroot_result')
                                                )
                                              }
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                    (command.ForEach
                                      iter_name: deplib
                                      iter_words: [{($ VSub_DollarName '$dependency_libs')}]
                                      do_arg_iter: F
                                      body: 
                                        (command.DoGroup
                                          children: [
                                            (C {(func_basename)} {(DQ ($ VSub_DollarName '$deplib'))})
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:deplib_base)
                                                  op: Equal
                                                  rhs: {($ VSub_DollarName '$func_basename_result')}
                                                )
                                              ]
                                            )
                                            (command.Case
                                              to_match: 
                                                {(DQ (' ') ($ VSub_DollarName '$weak_libs') (' '))}
                                              arms: [
                                                (case_arm
                                                  pat_list: [
                                                    {(Lit_Star '*') 
                                                      (DQ (' ') ($ VSub_DollarName '$deplib_base') 
                                                        (' ')
                                                      ) (Lit_Star '*')
                                                    }
                                                  ]
                                                )
                                                (case_arm
                                                  pat_list: [{(Lit_Star '*')}]
                                                  action: [
                                                    (C {(func_append)} {(deplibs)} 
                                                      {(DQ (' ') ($ VSub_DollarName '$deplib'))}
                                                    )
                                                  ]
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                    )
                                  ]
                                )
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:libs)
                                  op: Equal
                                  rhs: {($ VSub_DollarName '$dlprefiles')}
                                )
                              ]
                            )
                          ]
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: 
                                (C {(test)} {(dlopen)} {(Lit_Equals '=')} 
                                  {(DQ ($ VSub_DollarName '$pass'))}
                                )
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:save_deplibs)
                                  op: Equal
                                  rhs: {($ VSub_DollarName '$deplibs')}
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:deplibs) op:Equal rhs:(word.Empty))]
                            )
                          ]
                        )
                      ]
                    )
                    (command.ForEach
                      iter_name: deplib
                      iter_words: [{($ VSub_DollarName '$libs')}]
                      do_arg_iter: F
                      body: 
                        (command.DoGroup
                          children: [
                            (command.ShAssignment
                              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:lib) op:Equal rhs:(word.Empty))]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:found)
                                  op: Equal
                                  rhs: {(false)}
                                )
                              ]
                            )
                            (command.Case
                              to_match: {($ VSub_DollarName '$deplib')}
                              arms: [
                                (case_arm
                                  pat_list: [
                                    {(-mt)}
                                    {(-mthreads)}
                                    {(-kthread)}
                                    {(-Kthread)}
                                    {(-pthread)}
                                    {(-pthreads)}
                                    {(--thread-safe)}
                                    {(-threads)}
                                    {(-fopenmp)}
                                    {(-openmp)}
                                    {(-mp)}
                                    {(-xopenmp)}
                                    {(-omp)}
                                    {(-qsmp) (Lit_Equals '=') (Lit_Star '*')}
                                  ]
                                  action: [
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (command.Sentence
                                              child: 
                                                (C {(test)} {(prog) (Lit_Comma ',') (link)} 
                                                  {(Lit_Equals '=')} {(DQ ($ VSub_DollarName '$linkmode') (',') ($ VSub_DollarName '$pass'))}
                                                )
                                              terminator: <Op_Semi ';'>
                                            )
                                          ]
                                          action: [
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:compile_deplibs)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ ($ VSub_DollarName '$deplib') (' ') 
                                                        ($ VSub_DollarName '$compile_deplibs')
                                                      )
                                                    }
                                                )
                                              ]
                                            )
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:finalize_deplibs)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ ($ VSub_DollarName '$deplib') (' ') 
                                                        ($ VSub_DollarName '$finalize_deplibs')
                                                      )
                                                    }
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                      ]
                                      else_action: [
                                        (C {(func_append)} {(compiler_flags)} 
                                          {(DQ (' ') ($ VSub_DollarName '$deplib'))}
                                        )
                                        (command.If
                                          arms: [
                                            (if_arm
                                              cond: [
                                                (command.Sentence
                                                  child: 
                                                    (C {(test)} {(lib)} {(Lit_Equals '=')} 
                                                      {(DQ ($ VSub_DollarName '$linkmode'))}
                                                    )
                                                  terminator: <Op_Semi ';'>
                                                )
                                              ]
                                              action: [
                                                (command.Case
                                                  to_match: 
                                                    {
                                                      (DQ 
                                                        ($ VSub_DollarName 
'$new_inherited_linker_flags'
                                                        ) (' ')
                                                      )
                                                    }
                                                  arms: [
                                                    (case_arm
                                                      pat_list: [
                                                        {(Lit_Star '*') 
                                                          (DQ (' ') ($ VSub_DollarName '$deplib') (' ')) (Lit_Star '*')
                                                        }
                                                      ]
                                                    )
                                                    (case_arm
                                                      pat_list: [{(Lit_Star '*')}]
                                                      action: [
                                                        (C {(func_append)} 
                                                          {(new_inherited_linker_flags)} {(DQ (' ') ($ VSub_DollarName '$deplib'))}
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                    (command.ControlFlow
                                      token: <ControlFlow_Continue continue>
                                    )
                                  ]
                                )
                                (case_arm
                                  pat_list: [{(-l) (Lit_Star '*')}]
                                  action: [
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (command.Sentence
                                              child: 
                                                (command.AndOr
                                                  ops: [Op_DAmp]
                                                  children: [
                                                    (C {(test)} {(lib)} {(KW_Bang '!') (Lit_Equals '=')} 
                                                      {(DQ ($ VSub_DollarName '$linkmode'))}
                                                    )
                                                    (C {(test)} {(prog)} 
                                                      {(KW_Bang '!') (Lit_Equals '=')} {(DQ ($ VSub_DollarName '$linkmode'))}
                                                    )
                                                  ]
                                                )
                                              terminator: <Op_Semi ';'>
                                            )
                                          ]
                                          action: [
                                            (C {(func_warning)} 
                                              {(DQ ("'-l' is ignored for archives/objects"))}
                                            )
                                            (command.ControlFlow
                                              token: <ControlFlow_Continue continue>
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                    (C {(func_stripname)} {(SQ <-l>)} {(SQ )} 
                                      {(DQ ($ VSub_DollarName '$deplib'))}
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:name)
                                          op: Equal
                                          rhs: {($ VSub_DollarName '$func_stripname_result')}
                                        )
                                      ]
                                    )
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (command.Sentence
                                              child: 
                                                (C {(test)} {(lib)} {(Lit_Equals '=')} 
                                                  {(DQ ($ VSub_DollarName '$linkmode'))}
                                                )
                                              terminator: <Op_Semi ';'>
                                            )
                                          ]
                                          action: [
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:searchdirs)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ ($ VSub_DollarName '$newlib_search_path') 
                                                        (' ') ($ VSub_DollarName '$lib_search_path') (' ') ($ VSub_DollarName '$compiler_lib_search_dirs') (' ') 
                                                        ($ VSub_DollarName '$sys_lib_search_path') (' ') ($ VSub_DollarName '$shlib_search_path')
                                                      )
                                                    }
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                      ]
                                      else_action: [
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:searchdirs)
                                              op: Equal
                                              rhs: 
                                                {
                                                  (DQ ($ VSub_DollarName '$newlib_search_path') (' ') 
                                                    ($ VSub_DollarName '$lib_search_path') (' ') ($ VSub_DollarName '$sys_lib_search_path') (' ') ($ VSub_DollarName '$shlib_search_path')
                                                  )
                                                }
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                    (command.ForEach
                                      iter_name: searchdir
                                      iter_words: [{($ VSub_DollarName '$searchdirs')}]
                                      do_arg_iter: F
                                      body: 
                                        (command.DoGroup
                                          children: [
                                            (command.ForEach
                                              iter_name: search_ext
                                              iter_words: [
                                                {(.la)}
                                                {($ VSub_DollarName '$std_shrext')}
                                                {(.so)}
                                                {(.a)}
                                              ]
                                              do_arg_iter: F
                                              body: 
                                                (command.DoGroup
                                                  children: [
                                                    (command.ShAssignment
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (sh_lhs_expr.Name name:lib)
                                                          op: Equal
                                                          rhs: 
                                                            {($ VSub_DollarName '$searchdir') (/lib) 
                                                              ($ VSub_DollarName '$name') ($ VSub_DollarName '$search_ext')
                                                            }
                                                        )
                                                      ]
                                                    )
                                                    (command.If
                                                      arms: [
                                                        (if_arm
                                                          cond: [
                                                            (command.Sentence
                                                              child: 
                                                                (C {(test)} {(-f)} 
                                                                  {(DQ ($ VSub_DollarName '$lib'))}
                                                                )
                                                              terminator: <Op_Semi ';'>
                                                            )
                                                          ]
                                                          action: [
                                                            (command.If
                                                              arms: [
                                                                (if_arm
                                                                  cond: [
                                                                    (command.Sentence
                                                                      child: 
                                                                        (C {(test)} {(.la)} 
                                                                          {(Lit_Equals '=')} {(DQ ($ VSub_DollarName '$search_ext'))}
                                                                        )
                                                                      terminator: <Op_Semi ';'>
                                                                    )
                                                                  ]
                                                                  action: [
                                                                    (command.ShAssignment
                                                                      pairs: [
                                                                        (assign_pair
                                                                          lhs: 
                                                                            (sh_lhs_expr.Name
                                                                              name: found
                                                                            )
                                                                          op: Equal
                                                                          rhs: {(Lit_Other ':')}
                                                                        )
                                                                      ]
                                                                    )
                                                                  ]
                                                                )
                                                              ]
                                                              else_action: [
                                                                (command.ShAssignment
                                                                  pairs: [
                                                                    (assign_pair
                                                                      lhs: 
                                                                        (sh_lhs_expr.Name
                                                                          name: found
                                                                        )
                                                                      op: Equal
                                                                      rhs: {(false)}
                                                                    )
                                                                  ]
                                                                )
                                                              ]
                                                            )
                                                            (command.ControlFlow
                                                              token: <ControlFlow_Break break>
                                                              arg_word: {(2)}
                                                            )
                                                          ]
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                )
                                            )
                                          ]
                                        )
                                    )
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (command.Sentence
                                              child: (C {($ VSub_DollarName '$found')})
                                              terminator: <Op_Semi ';'>
                                            )
                                          ]
                                          action: [
                                            (command.If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (command.Sentence
                                                      child: 
                                                        (C {(test)} {(yes)} {(Lit_Equals '=')} 
                                                          {
                                                            (DQ 
                                                              ($ VSub_DollarName 
'$allow_libtool_libs_with_static_runtimes'
                                                              )
                                                            )
                                                          }
                                                        )
                                                      terminator: <Op_Semi ';'>
                                                    )
                                                  ]
                                                  action: [
                                                    (command.Case
                                                      to_match: 
                                                        {
                                                          (DQ (' ') ($ VSub_DollarName '$predeps') 
                                                            (' ') ($ VSub_DollarName '$postdeps') (' ')
                                                          )
                                                        }
                                                      arms: [
                                                        (case_arm
                                                          pat_list: [
                                                            {(Lit_Star '*') 
                                                              (DQ (' ') ($ VSub_DollarName '$deplib') 
                                                                (' ')
                                                              ) (Lit_Star '*')
                                                            }
                                                          ]
                                                          action: [
                                                            (command.If
                                                              arms: [
                                                                (if_arm
                                                                  cond: [
                                                                    (command.Sentence
                                                                      child: 
                                                                        (C {(func_lalib_p)} 
                                                                          {
                                                                            (DQ 
                                                                              ($ VSub_DollarName 
'$lib'
                                                                              )
                                                                            )
                                                                          }
                                                                        )
                                                                      terminator: <Op_Semi ';'>
                                                                    )
                                                                  ]
                                                                  action: [
                                                                    (command.ShAssignment
                                                                      pairs: [
                                                                        (assign_pair
                                                                          lhs: 
                                                                            (sh_lhs_expr.Name
                                                                              name: library_names
                                                                            )
                                                                          op: Equal
                                                                          rhs: (word.Empty)
                                                                        )
                                                                      ]
                                                                    )
                                                                    (command.ShAssignment
                                                                      pairs: [
                                                                        (assign_pair
                                                                          lhs: 
                                                                            (sh_lhs_expr.Name
                                                                              name: old_library
                                                                            )
                                                                          op: Equal
                                                                          rhs: (word.Empty)
                                                                        )
                                                                      ]
                                                                    )
                                                                    (C {(func_source)} 
                                                                      {
                                                                        (DQ 
                                                                          ($ VSub_DollarName '$lib')
                                                                        )
                                                                      }
                                                                    )
                                                                    (command.ForEach
                                                                      iter_name: l
                                                                      iter_words: [
                                                                        {
                                                                          ($ VSub_DollarName 
'$old_library'
                                                                          )
                                                                        }
                                                                        {
                                                                          ($ VSub_DollarName 
'$library_names'
                                                                          )
                                                                        }
                                                                      ]
                                                                      do_arg_iter: F
                                                                      body: 
                                                                        (command.DoGroup
                                                                          children: [
                                                                            (command.ShAssignment
                                                                              pairs: [
                                                                                (assign_pair
                                                                                  lhs: 
                                                                                    (sh_lhs_expr.Name
                                                                                      name: ll
                                                                                    )
                                                                                  op: Equal
                                                                                  rhs: 
                                                                                    {
                                                                                      ($ 
VSub_DollarName '$l'
                                                                                      )
                                                                                    }
                                                                                )
                                                                              ]
                                                                            )
                                                                          ]
                                                                        )
                                                                    )
                                                                    (command.If
                                                                      arms: [
                                                                        (if_arm
                                                                          cond: [
                                                                            (command.Sentence
                                                                              child: 
                                                                                (C {(test)} 
                                                                                  {
                                                                                    (DQ (X) 
                                                                                      ($ 
VSub_DollarName '$ll'
                                                                                      )
                                                                                    )
                                                                                  } {(Lit_Equals '=')} {(DQ (X) ($ VSub_DollarName '$old_library'))}
                                                                                )
                                                                              terminator: 
                                                                                <Op_Semi ';'>
                                                                            )
                                                                          ]
                                                                          action: [
                                                                            (command.ShAssignment
                                                                              pairs: [
                                                                                (assign_pair
                                                                                  lhs: 
                                                                                    (sh_lhs_expr.Name
                                                                                      name: found
                                                                                    )
                                                                                  op: Equal
                                                                                  rhs: {(false)}
                                                                                )
                                                                              ]
                                                                            )
                                                                            (C {(func_dirname)} 
                                                                              {
                                                                                (DQ 
                                                                                  ($ VSub_DollarName 
'$lib'
                                                                                  )
                                                                                )
                                                                              } {(DQ )} {(DQ (.))}
                                                                            )
                                                                            (command.ShAssignment
                                                                              pairs: [
                                                                                (assign_pair
                                                                                  lhs: 
                                                                                    (sh_lhs_expr.Name
                                                                                      name: ladir
                                                                                    )
                                                                                  op: Equal
                                                                                  rhs: 
                                                                                    {
                                                                                      ($ 
VSub_DollarName '$func_dirname_result'
                                                                                      )
                                                                                    }
                                                                                )
                                                                              ]
                                                                            )
                                                                            (command.ShAssignment
                                                                              pairs: [
                                                                                (assign_pair
                                                                                  lhs: 
                                                                                    (sh_lhs_expr.Name
                                                                                      name: lib
                                                                                    )
                                                                                  op: Equal
                                                                                  rhs: 
                                                                                    {
                                                                                      ($ 
VSub_DollarName '$ladir'
                                                                                      ) (/) ($ VSub_DollarName '$old_library')
                                                                                    }
                                                                                )
                                                                              ]
                                                                            )
                                                                            (command.If
                                                                              arms: [
                                                                                (if_arm
                                                                                  cond: [
                                                                                    (command.Sentence
                                                                                      child: 
                                                                                        (C {(test)} 
                                                                                          {(prog) 
                                                                                            (
Lit_Comma ','
                                                                                            ) (link)
                                                                                          } {(Lit_Equals '=')} {(DQ ($ VSub_DollarName '$linkmode') (',') ($ VSub_DollarName '$pass'))}
                                                                                        )
                                                                                      terminator: 
                                                                                        <Op_Semi ';'>
                                                                                    )
                                                                                  ]
                                                                                  action: [
                                                                                    (command.ShAssignment
                                                                                      pairs: [
                                                                                        (assign_pair
                                                                                          lhs: 
                                                                                            (sh_lhs_expr.Name
                                                                                              name: 
compile_deplibs
                                                                                            )
                                                                                          op: Equal
                                                                                          rhs: 
                                                                                            {
                                                                                              (DQ 
                                                                                                ($ 
VSub_DollarName '$deplib'
                                                                                                ) (' ') ($ VSub_DollarName '$compile_deplibs')
                                                                                              )
                                                                                            }
                                                                                        )
                                                                                      ]
                                                                                    )
                                                                                    (command.ShAssignment
                                                                                      pairs: [
                                                                                        (assign_pair
                                                                                          lhs: 
                                                                                            (sh_lhs_expr.Name
                                                                                              name: 
finalize_deplibs
                                                                                            )
                                                                                          op: Equal
                                                                                          rhs: 
                                                                                            {
                                                                                              (DQ 
                                                                                                ($ 
VSub_DollarName '$deplib'
                                                                                                ) (' ') ($ VSub_DollarName '$finalize_deplibs')
                                                                                              )
                                                                                            }
                                                                                        )
                                                                                      ]
                                                                                    )
                                                                                  ]
                                                                                )
                                                                              ]
                                                                              else_action: [
                                                                                (command.ShAssignment
                                                                                  pairs: [
                                                                                    (assign_pair
                                                                                      lhs: 
                                                                                        (sh_lhs_expr.Name
                                                                                          name: 
deplibs
                                                                                        )
                                                                                      op: Equal
                                                                                      rhs: 
                                                                                        {
                                                                                          (DQ 
                                                                                            ($ 
VSub_DollarName '$deplib'
                                                                                            ) (' ') ($ VSub_DollarName '$deplibs')
                                                                                          )
                                                                                        }
                                                                                    )
                                                                                  ]
                                                                                )
                                                                                (command.AndOr
                                                                                  ops: [Op_DAmp]
                                                                                  children: [
                                                                                    (C {(test)} {(lib)} 
                                                                                      {
                                                                                        (Lit_Equals 
'='
                                                                                        )
                                                                                      } {(DQ ($ VSub_DollarName '$linkmode'))}
                                                                                    )
                                                                                    (command.ShAssignment
                                                                                      pairs: [
                                                                                        (assign_pair
                                                                                          lhs: 
                                                                                            (sh_lhs_expr.Name
                                                                                              name: 
newdependency_libs
                                                                                            )
                                                                                          op: Equal
                                                                                          rhs: 
                                                                                            {
                                                                                              (DQ 
                                                                                                ($ 
VSub_DollarName '$deplib'
                                                                                                ) (' ') ($ VSub_DollarName '$newdependency_libs')
                                                                                              )
                                                                                            }
                                                                                        )
                                                                                      ]
                                                                                    )
                                                                                  ]
                                                                                )
                                                                              ]
                                                                            )
                                                                            (command.ControlFlow
                                                                              token: 
                                                                                <
ControlFlow_Continue continue
                                                                                >
                                                                            )
                                                                          ]
                                                                        )
                                                                      ]
                                                                    )
                                                                  ]
                                                                )
                                                              ]
                                                            )
                                                          ]
                                                        )
                                                        (case_arm
                                                          pat_list: [{(Lit_Star '*')}]
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                      ]
                                      else_action: [
                                        (command.If
                                          arms: [
                                            (if_arm
                                              cond: [
                                                (command.Sentence
                                                  child: 
                                                    (C {(test)} {(prog) (Lit_Comma ',') (link)} 
                                                      {(Lit_Equals '=')} {(DQ ($ VSub_DollarName '$linkmode') (',') ($ VSub_DollarName '$pass'))}
                                                    )
                                                  terminator: <Op_Semi ';'>
                                                )
                                              ]
                                              action: [
                                                (command.ShAssignment
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (sh_lhs_expr.Name name:compile_deplibs)
                                                      op: Equal
                                                      rhs: 
                                                        {
                                                          (DQ ($ VSub_DollarName '$deplib') (' ') 
                                                            ($ VSub_DollarName '$compile_deplibs')
                                                          )
                                                        }
                                                    )
                                                  ]
                                                )
                                                (command.ShAssignment
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (sh_lhs_expr.Name name:finalize_deplibs)
                                                      op: Equal
                                                      rhs: 
                                                        {
                                                          (DQ ($ VSub_DollarName '$deplib') (' ') 
                                                            ($ VSub_DollarName '$finalize_deplibs')
                                                          )
                                                        }
                                                    )
                                                  ]
                                                )
                                              ]
                                            )
                                          ]
                                          else_action: [
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:deplibs)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ ($ VSub_DollarName '$deplib') (' ') 
                                                        ($ VSub_DollarName '$deplibs')
                                                      )
                                                    }
                                                )
                                              ]
                                            )
                                            (command.AndOr
                                              ops: [Op_DAmp]
                                              children: [
                                                (C {(test)} {(lib)} {(Lit_Equals '=')} 
                                                  {(DQ ($ VSub_DollarName '$linkmode'))}
                                                )
                                                (command.ShAssignment
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (sh_lhs_expr.Name name:newdependency_libs)
                                                      op: Equal
                                                      rhs: 
                                                        {
                                                          (DQ ($ VSub_DollarName '$deplib') (' ') 
                                                            ($ VSub_DollarName '$newdependency_libs')
                                                          )
                                                        }
                                                    )
                                                  ]
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                        (command.ControlFlow
                                          token: <ControlFlow_Continue continue>
                                        )
                                      ]
                                    )
                                  ]
                                )
                                (case_arm
                                  pat_list: [{(Lit_Star '*') (.ltframework)}]
                                  action: [
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (command.Sentence
                                              child: 
                                                (C {(test)} {(prog) (Lit_Comma ',') (link)} 
                                                  {(Lit_Equals '=')} {(DQ ($ VSub_DollarName '$linkmode') (',') ($ VSub_DollarName '$pass'))}
                                                )
                                              terminator: <Op_Semi ';'>
                                            )
                                          ]
                                          action: [
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:compile_deplibs)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ ($ VSub_DollarName '$deplib') (' ') 
                                                        ($ VSub_DollarName '$compile_deplibs')
                                                      )
                                                    }
                                                )
                                              ]
                                            )
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:finalize_deplibs)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ ($ VSub_DollarName '$deplib') (' ') 
                                                        ($ VSub_DollarName '$finalize_deplibs')
                                                      )
                                                    }
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                      ]
                                      else_action: [
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:deplibs)
                                              op: Equal
                                              rhs: 
                                                {
                                                  (DQ ($ VSub_DollarName '$deplib') (' ') 
                                                    ($ VSub_DollarName '$deplibs')
                                                  )
                                                }
                                            )
                                          ]
                                        )
                                        (command.If
                                          arms: [
                                            (if_arm
                                              cond: [
                                                (command.Sentence
                                                  child: 
                                                    (C {(test)} {(lib)} {(Lit_Equals '=')} 
                                                      {(DQ ($ VSub_DollarName '$linkmode'))}
                                                    )
                                                  terminator: <Op_Semi ';'>
                                                )
                                              ]
                                              action: [
                                                (command.Case
                                                  to_match: 
                                                    {
                                                      (DQ 
                                                        ($ VSub_DollarName 
'$new_inherited_linker_flags'
                                                        ) (' ')
                                                      )
                                                    }
                                                  arms: [
                                                    (case_arm
                                                      pat_list: [
                                                        {(Lit_Star '*') 
                                                          (DQ (' ') ($ VSub_DollarName '$deplib') (' ')) (Lit_Star '*')
                                                        }
                                                      ]
                                                    )
                                                    (case_arm
                                                      pat_list: [{(Lit_Star '*')}]
                                                      action: [
                                                        (C {(func_append)} 
                                                          {(new_inherited_linker_flags)} {(DQ (' ') ($ VSub_DollarName '$deplib'))}
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                    (command.ControlFlow
                                      token: <ControlFlow_Continue continue>
                                    )
                                  ]
                                )
                                (case_arm
                                  pat_list: [{(-L) (Lit_Star '*')}]
                                  action: [
                                    (command.Case
                                      to_match: {($ VSub_DollarName '$linkmode')}
                                      arms: [
                                        (case_arm
                                          pat_list: [{(lib)}]
                                          action: [
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:deplibs)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ ($ VSub_DollarName '$deplib') (' ') 
                                                        ($ VSub_DollarName '$deplibs')
                                                      )
                                                    }
                                                )
                                              ]
                                            )
                                            (command.AndOr
                                              ops: [Op_DAmp]
                                              children: [
                                                (C {(test)} {(conv)} {(Lit_Equals '=')} 
                                                  {(DQ ($ VSub_DollarName '$pass'))}
                                                )
                                                (command.ControlFlow
                                                  token: <ControlFlow_Continue continue>
                                                )
                                              ]
                                            )
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:newdependency_libs)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ ($ VSub_DollarName '$deplib') (' ') 
                                                        ($ VSub_DollarName '$newdependency_libs')
                                                      )
                                                    }
                                                )
                                              ]
                                            )
                                            (C {(func_stripname)} {(SQ <-L>)} {(SQ )} 
                                              {(DQ ($ VSub_DollarName '$deplib'))}
                                            )
                                            (C {(func_resolve_sysroot)} 
                                              {(DQ ($ VSub_DollarName '$func_stripname_result'))}
                                            )
                                            (C {(func_append)} {(newlib_search_path)} 
                                              {
                                                (DQ (' ') 
                                                  ($ VSub_DollarName '$func_resolve_sysroot_result')
                                                )
                                              }
                                            )
                                          ]
                                        )
                                        (case_arm
                                          pat_list: [{(prog)}]
                                          action: [
                                            (command.If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (command.Sentence
                                                      child: 
                                                        (C {(test)} {(conv)} {(Lit_Equals '=')} 
                                                          {(DQ ($ VSub_DollarName '$pass'))}
                                                        )
                                                      terminator: <Op_Semi ';'>
                                                    )
                                                  ]
                                                  action: [
                                                    (command.ShAssignment
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (sh_lhs_expr.Name name:deplibs)
                                                          op: Equal
                                                          rhs: 
                                                            {
                                                              (DQ ($ VSub_DollarName '$deplib') (' ') 
                                                                ($ VSub_DollarName '$deplibs')
                                                              )
                                                            }
                                                        )
                                                      ]
                                                    )
                                                    (command.ControlFlow
                                                      token: <ControlFlow_Continue continue>
                                                    )
                                                  ]
                                                )
                                              ]
                                            )
                                            (command.If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (command.Sentence
                                                      child: 
                                                        (C {(test)} {(scan)} {(Lit_Equals '=')} 
                                                          {(DQ ($ VSub_DollarName '$pass'))}
                                                        )
                                                      terminator: <Op_Semi ';'>
                                                    )
                                                  ]
                                                  action: [
                                                    (command.ShAssignment
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (sh_lhs_expr.Name name:deplibs)
                                                          op: Equal
                                                          rhs: 
                                                            {
                                                              (DQ ($ VSub_DollarName '$deplib') (' ') 
                                                                ($ VSub_DollarName '$deplibs')
                                                              )
                                                            }
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                )
                                              ]
                                              else_action: [
                                                (command.ShAssignment
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (sh_lhs_expr.Name name:compile_deplibs)
                                                      op: Equal
                                                      rhs: 
                                                        {
                                                          (DQ ($ VSub_DollarName '$deplib') (' ') 
                                                            ($ VSub_DollarName '$compile_deplibs')
                                                          )
                                                        }
                                                    )
                                                  ]
                                                )
                                                (command.ShAssignment
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (sh_lhs_expr.Name name:finalize_deplibs)
                                                      op: Equal
                                                      rhs: 
                                                        {
                                                          (DQ ($ VSub_DollarName '$deplib') (' ') 
                                                            ($ VSub_DollarName '$finalize_deplibs')
                                                          )
                                                        }
                                                    )
                                                  ]
                                                )
                                              ]
                                            )
                                            (C {(func_stripname)} {(SQ <-L>)} {(SQ )} 
                                              {(DQ ($ VSub_DollarName '$deplib'))}
                                            )
                                            (C {(func_resolve_sysroot)} 
                                              {(DQ ($ VSub_DollarName '$func_stripname_result'))}
                                            )
                                            (C {(func_append)} {(newlib_search_path)} 
                                              {
                                                (DQ (' ') 
                                                  ($ VSub_DollarName '$func_resolve_sysroot_result')
                                                )
                                              }
                                            )
                                          ]
                                        )
                                        (case_arm
                                          pat_list: [{(Lit_Star '*')}]
                                          action: [
                                            (C {(func_warning)} 
                                              {(DQ ("'-L' is ignored for archives/objects"))}
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                    (command.ControlFlow
                                      token: <ControlFlow_Continue continue>
                                    )
                                  ]
                                )
                                (case_arm
                                  pat_list: [{(-R) (Lit_Star '*')}]
                                  action: [
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (command.Sentence
                                              child: 
                                                (C {(test)} {(link)} {(Lit_Equals '=')} 
                                                  {(DQ ($ VSub_DollarName '$pass'))}
                                                )
                                              terminator: <Op_Semi ';'>
                                            )
                                          ]
                                          action: [
                                            (C {(func_stripname)} {(SQ <-R>)} {(SQ )} 
                                              {(DQ ($ VSub_DollarName '$deplib'))}
                                            )
                                            (C {(func_resolve_sysroot)} 
                                              {(DQ ($ VSub_DollarName '$func_stripname_result'))}
                                            )
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:dir)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      ($ VSub_DollarName 
'$func_resolve_sysroot_result'
                                                      )
                                                    }
                                                )
                                              ]
                                            )
                                            (command.Case
                                              to_match: {(DQ ($ VSub_DollarName '$xrpath') (' '))}
                                              arms: [
                                                (case_arm
                                                  pat_list: [
                                                    {(Lit_Star '*') 
                                                      (DQ (' ') ($ VSub_DollarName '$dir') (' ')) (Lit_Star '*')
                                                    }
                                                  ]
                                                )
                                                (case_arm
                                                  pat_list: [{(Lit_Star '*')}]
                                                  action: [
                                                    (C {(func_append)} {(xrpath)} 
                                                      {(DQ (' ') ($ VSub_DollarName '$dir'))}
                                                    )
                                                  ]
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:deplibs)
                                          op: Equal
                                          rhs: 
                                            {
                                              (DQ ($ VSub_DollarName '$deplib') (' ') 
                                                ($ VSub_DollarName '$deplibs')
                                              )
                                            }
                                        )
                                      ]
                                    )
                                    (command.ControlFlow
                                      token: <ControlFlow_Continue continue>
                                    )
                                  ]
                                )
                                (case_arm
                                  pat_list: [{(Lit_Star '*') (.la)}]
                                  action: [
                                    (C {(func_resolve_sysroot)} {(DQ ($ VSub_DollarName '$deplib'))})
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:lib)
                                          op: Equal
                                          rhs: {($ VSub_DollarName '$func_resolve_sysroot_result')}
                                        )
                                      ]
                                    )
                                  ]
                                )
                                (case_arm
                                  pat_list: [{(Lit_Star '*') (.) ($ VSub_DollarName '$libext')}]
                                  action: [
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (command.Sentence
                                              child: 
                                                (C {(test)} {(conv)} {(Lit_Equals '=')} 
                                                  {(DQ ($ VSub_DollarName '$pass'))}
                                                )
                                              terminator: <Op_Semi ';'>
                                            )
                                          ]
                                          action: [
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:deplibs)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ ($ VSub_DollarName '$deplib') (' ') 
                                                        ($ VSub_DollarName '$deplibs')
                                                      )
                                                    }
                                                )
                                              ]
                                            )
                                            (command.ControlFlow
                                              token: <ControlFlow_Continue continue>
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                    (command.Case
                                      to_match: {($ VSub_DollarName '$linkmode')}
                                      arms: [
                                        (case_arm
                                          pat_list: [{(lib)}]
                                          action: [
                                            (command.Case
                                              to_match: 
                                                {
                                                  (DQ (' ') 
                                                    ($ VSub_DollarName '$dlpreconveniencelibs') (' ')
                                                  )
                                                }
                                              arms: [
                                                (case_arm
                                                  pat_list: [
                                                    {(Lit_Star '*') 
                                                      (DQ (' ') ($ VSub_DollarName '$deplib') (' ')) (Lit_Star '*')
                                                    }
                                                  ]
                                                )
                                                (case_arm
                                                  pat_list: [{(Lit_Star '*')}]
                                                  action: [
                                                    (command.ShAssignment
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (sh_lhs_expr.Name name:valid_a_lib)
                                                          op: Equal
                                                          rhs: {(false)}
                                                        )
                                                      ]
                                                    )
                                                    (command.Case
                                                      to_match: 
                                                        {($ VSub_DollarName '$deplibs_check_method')}
                                                      arms: [
                                                        (case_arm
                                                          pat_list: [{(match_pattern) (Lit_Star '*')}]
                                                          action: [
                                                            (command.Sentence
                                                              child: 
                                                                (C {(KW_Set set)} {(dummy)} 
                                                                  {
                                                                    ($ VSub_DollarName 
'$deplibs_check_method'
                                                                    )
                                                                  }
                                                                )
                                                              terminator: <Op_Semi ';'>
                                                            )
                                                            (C {(shift)})
                                                            (command.ShAssignment
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: 
                                                                    (sh_lhs_expr.Name
                                                                      name: match_pattern_regex
                                                                    )
                                                                  op: Equal
                                                                  rhs: 
                                                                    {
                                                                      (command_sub
                                                                        left_token: 
                                                                          <Left_Backtick '`'>
                                                                        command_list: 
                                                                          (command.CommandList
                                                                            children: [
                                                                              (C {(expr)} 
                                                                                {
                                                                                  (DQ 
                                                                                    ($ 
VSub_DollarName '$deplibs_check_method'
                                                                                    )
                                                                                  )
                                                                                } {(Lit_Other ':')} {(DQ ($ VSub_Number '$1') (' ') (Lit_Other '\\') ('(.*') (Lit_Other '\\') (')'))}
                                                                              )
                                                                            ]
                                                                          )
                                                                      )
                                                                    }
                                                                )
                                                              ]
                                                            )
                                                            (command.If
                                                              arms: [
                                                                (if_arm
                                                                  cond: [
                                                                    (command.Sentence
                                                                      child: 
                                                                        (command.Pipeline
                                                                          children: [
                                                                            (command.Simple
                                                                              words: [
                                                                                {(eval)}
                                                                                {
                                                                                  (DQ 
                                                                                    (word_part.EscapedLiteral
                                                                                      token: 
                                                                                        <
Lit_EscapedChar '\\$'
                                                                                        >
                                                                                    ) ('ECHO ') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) ($ VSub_DollarName '$deplib') 
                                                                                    (word_part.EscapedLiteral
                                                                                      token: 
                                                                                        <
Lit_EscapedChar '\\"'
                                                                                        >
                                                                                    )
                                                                                  )
                                                                                }
                                                                              ]
                                                                              redirects: [
                                                                                (redir.Redir
                                                                                  op: 
                                                                                    <Redir_Great 
'2>'
                                                                                    >
                                                                                  fd: 2
                                                                                  arg_word: 
                                                                                    {(/dev/null)}
                                                                                )
                                                                              ]
                                                                            )
                                                                            (C 
                                                                              {
                                                                                ($ VSub_DollarName 
'$SED'
                                                                                )
                                                                              } {(10q)}
                                                                            )
                                                                            (command.Simple
                                                                              words: [
                                                                                {
                                                                                  ($ VSub_DollarName 
'$EGREP'
                                                                                  )
                                                                                }
                                                                                {
                                                                                  (DQ 
                                                                                    ($ 
VSub_DollarName '$match_pattern_regex'
                                                                                    )
                                                                                  )
                                                                                }
                                                                              ]
                                                                              redirects: [
                                                                                (redir.Redir
                                                                                  op: 
                                                                                    <Redir_Great '>'>
                                                                                  fd: 16777215
                                                                                  arg_word: 
                                                                                    {(/dev/null)}
                                                                                )
                                                                              ]
                                                                            )
                                                                          ]
                                                                          negated: F
                                                                        )
                                                                      terminator: <Op_Semi ';'>
                                                                    )
                                                                  ]
                                                                  action: [
                                                                    (command.ShAssignment
                                                                      pairs: [
                                                                        (assign_pair
                                                                          lhs: 
                                                                            (sh_lhs_expr.Name
                                                                              name: valid_a_lib
                                                                            )
                                                                          op: Equal
                                                                          rhs: {(Lit_Other ':')}
                                                                        )
                                                                      ]
                                                                    )
                                                                  ]
                                                                )
                                                              ]
                                                            )
                                                          ]
                                                        )
                                                        (case_arm
                                                          pat_list: [{(pass_all)}]
                                                          action: [
                                                            (command.ShAssignment
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: 
                                                                    (sh_lhs_expr.Name
                                                                      name: valid_a_lib
                                                                    )
                                                                  op: Equal
                                                                  rhs: {(Lit_Other ':')}
                                                                )
                                                              ]
                                                            )
                                                          ]
                                                        )
                                                      ]
                                                    )
                                                    (command.If
                                                      arms: [
                                                        (if_arm
                                                          cond: [
                                                            (command.Sentence
                                                              child: 
                                                                (C 
                                                                  {
                                                                    ($ VSub_DollarName '$valid_a_lib')
                                                                  }
                                                                )
                                                              terminator: <Op_Semi ';'>
                                                            )
                                                          ]
                                                          action: [
                                                            (C {(echo)})
                                                            (C {($ VSub_DollarName '$ECHO')} 
                                                              {
                                                                (DQ 
                                                                  (
'*** Warning: Linking the shared library '
                                                                  ) ($ VSub_DollarName '$output') (' against the')
                                                                )
                                                              }
                                                            )
                                                            (C {($ VSub_DollarName '$ECHO')} 
                                                              {
                                                                (DQ ('*** static library ') 
                                                                  ($ VSub_DollarName '$deplib') (' is not portable!')
                                                                )
                                                              }
                                                            )
                                                            (command.ShAssignment
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: 
                                                                    (sh_lhs_expr.Name
                                                                      name: deplibs
                                                                    )
                                                                  op: Equal
                                                                  rhs: 
                                                                    {
                                                                      (DQ 
                                                                        ($ VSub_DollarName '$deplib') (' ') ($ VSub_DollarName '$deplibs')
                                                                      )
                                                                    }
                                                                )
                                                              ]
                                                            )
                                                          ]
                                                        )
                                                      ]
                                                      else_action: [
                                                        (C {(echo)})
                                                        (C {($ VSub_DollarName '$ECHO')} 
                                                          {
                                                            (DQ 
                                                              (
'*** Warning: Trying to link with static lib archive '
                                                              ) ($ VSub_DollarName '$deplib') (.)
                                                            )
                                                          }
                                                        )
                                                        (C {(echo)} 
                                                          {
                                                            (DQ 
                                                              (
'*** I have the capability to make that library automatically link in when'
                                                              )
                                                            )
                                                          }
                                                        )
                                                        (C {(echo)} 
                                                          {
                                                            (DQ 
                                                              (
'*** you link to this library.  But I can only do this if you have a'
                                                              )
                                                            )
                                                          }
                                                        )
                                                        (C {(echo)} 
                                                          {
                                                            (DQ 
                                                              (
'*** shared version of the library, which you do not appear to have'
                                                              )
                                                            )
                                                          }
                                                        )
                                                        (C {(echo)} 
                                                          {
                                                            (DQ ('*** because the file extensions .') 
                                                              ($ VSub_DollarName '$libext') (' of this argument makes me believe')
                                                            )
                                                          }
                                                        )
                                                        (C {(echo)} 
                                                          {
                                                            (DQ 
                                                              (
'*** that it is just a static archive that I should not use here.'
                                                              )
                                                            )
                                                          }
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                )
                                              ]
                                            )
                                            (command.ControlFlow
                                              token: <ControlFlow_Continue continue>
                                            )
                                          ]
                                        )
                                        (case_arm
                                          pat_list: [{(prog)}]
                                          action: [
                                            (command.If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (command.Sentence
                                                      child: 
                                                        (C {(test)} {(link)} 
                                                          {(KW_Bang '!') (Lit_Equals '=')} {(DQ ($ VSub_DollarName '$pass'))}
                                                        )
                                                      terminator: <Op_Semi ';'>
                                                    )
                                                  ]
                                                  action: [
                                                    (command.ShAssignment
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (sh_lhs_expr.Name name:deplibs)
                                                          op: Equal
                                                          rhs: 
                                                            {
                                                              (DQ ($ VSub_DollarName '$deplib') (' ') 
                                                                ($ VSub_DollarName '$deplibs')
                                                              )
                                                            }
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                )
                                              ]
                                              else_action: [
                                                (command.ShAssignment
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (sh_lhs_expr.Name name:compile_deplibs)
                                                      op: Equal
                                                      rhs: 
                                                        {
                                                          (DQ ($ VSub_DollarName '$deplib') (' ') 
                                                            ($ VSub_DollarName '$compile_deplibs')
                                                          )
                                                        }
                                                    )
                                                  ]
                                                )
                                                (command.ShAssignment
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (sh_lhs_expr.Name name:finalize_deplibs)
                                                      op: Equal
                                                      rhs: 
                                                        {
                                                          (DQ ($ VSub_DollarName '$deplib') (' ') 
                                                            ($ VSub_DollarName '$finalize_deplibs')
                                                          )
                                                        }
                                                    )
                                                  ]
                                                )
                                              ]
                                            )
                                            (command.ControlFlow
                                              token: <ControlFlow_Continue continue>
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                  ]
                                )
                                (case_arm
                                  pat_list: [
                                    {(Lit_Star '*') (.lo)}
                                    {(Lit_Star '*') (.) ($ VSub_DollarName '$objext')}
                                  ]
                                  action: [
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (command.Sentence
                                              child: 
                                                (C {(test)} {(conv)} {(Lit_Equals '=')} 
                                                  {(DQ ($ VSub_DollarName '$pass'))}
                                                )
                                              terminator: <Op_Semi ';'>
                                            )
                                          ]
                                          action: [
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:deplibs)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ ($ VSub_DollarName '$deplib') (' ') 
                                                        ($ VSub_DollarName '$deplibs')
                                                      )
                                                    }
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                        (if_arm
                                          cond: [
                                            (command.Sentence
                                              child: 
                                                (C {(test)} {(prog)} {(Lit_Equals '=')} 
                                                  {(DQ ($ VSub_DollarName '$linkmode'))}
                                                )
                                              terminator: <Op_Semi ';'>
                                            )
                                          ]
                                          action: [
                                            (command.If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (command.Sentence
                                                      child: 
                                                        (command.AndOr
                                                          ops: [Op_DPipe Op_DPipe]
                                                          children: [
                                                            (C {(test)} {(dlpreopen)} {(Lit_Equals '=')} 
                                                              {(DQ ($ VSub_DollarName '$pass'))}
                                                            )
                                                            (C {(test)} {(yes)} 
                                                              {(KW_Bang '!') (Lit_Equals '=')} {(DQ ($ VSub_DollarName '$dlopen_support'))}
                                                            )
                                                            (C {(test)} {(no)} {(Lit_Equals '=')} 
                                                              {
                                                                (DQ 
                                                                  ($ VSub_DollarName 
'$build_libtool_libs'
                                                                  )
                                                                )
                                                              }
                                                            )
                                                          ]
                                                        )
                                                      terminator: <Op_Semi ';'>
                                                    )
                                                  ]
                                                  action: [
                                                    (C {(func_append)} {(newdlprefiles)} 
                                                      {(DQ (' ') ($ VSub_DollarName '$deplib'))}
                                                    )
                                                    (command.ShAssignment
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: 
                                                            (sh_lhs_expr.Name
                                                              name: compile_deplibs
                                                            )
                                                          op: Equal
                                                          rhs: 
                                                            {
                                                              (DQ ($ VSub_DollarName '$deplib') (' ') 
                                                                ($ VSub_DollarName '$compile_deplibs')
                                                              )
                                                            }
                                                        )
                                                      ]
                                                    )
                                                    (command.ShAssignment
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: 
                                                            (sh_lhs_expr.Name
                                                              name: finalize_deplibs
                                                            )
                                                          op: Equal
                                                          rhs: 
                                                            {
                                                              (DQ ($ VSub_DollarName '$deplib') (' ') 
                                                                ($ VSub_DollarName 
'$finalize_deplibs'
                                                                )
                                                              )
                                                            }
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                )
                                              ]
                                              else_action: [
                                                (C {(func_append)} {(newdlfiles)} 
                                                  {(DQ (' ') ($ VSub_DollarName '$deplib'))}
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                    (command.ControlFlow
                                      token: <ControlFlow_Continue continue>
                                    )
                                  ]
                                )
                                (case_arm
                                  pat_list: [{(Lit_Other '%') (DEPLIBS) (Lit_Other '%')}]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:alldeplibs)
                                          op: Equal
                                          rhs: {(Lit_Other ':')}
                                        )
                                      ]
                                    )
                                    (command.ControlFlow
                                      token: <ControlFlow_Continue continue>
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.AndOr
                              ops: [Op_DPipe Op_DPipe]
                              children: [
                                (C {($ VSub_DollarName '$found')})
                                (C {(test)} {(-f)} {(DQ ($ VSub_DollarName '$lib'))})
                                (C {(func_fatal_error)} 
                                  {
                                    (DQ ("cannot find the library '") ($ VSub_DollarName '$lib') 
                                      ("' or unhandled argument '") ($ VSub_DollarName '$deplib') ("'")
                                    )
                                  }
                                )
                              ]
                            )
                            (command.AndOr
                              ops: [Op_DPipe]
                              children: [
                                (C {(func_lalib_unsafe_p)} {(DQ ($ VSub_DollarName '$lib'))})
                                (C {(func_fatal_error)} 
                                  {
                                    (DQ ("'") ($ VSub_DollarName '$lib') 
                                      ("' is not a valid libtool archive")
                                    )
                                  }
                                )
                              ]
                            )
                            (C {(func_dirname)} {(DQ ($ VSub_DollarName '$lib'))} {(DQ )} {(DQ (.))})
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:ladir)
                                  op: Equal
                                  rhs: {($ VSub_DollarName '$func_dirname_result')}
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:dlname) op:Equal rhs:(word.Empty))]
                            )
                            (command.ShAssignment
                              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:dlopen) op:Equal rhs:(word.Empty))]
                            )
                            (command.ShAssignment
                              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:dlpreopen) op:Equal rhs:(word.Empty))]
                            )
                            (command.ShAssignment
                              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:libdir) op:Equal rhs:(word.Empty))]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:library_names)
                                  op: Equal
                                  rhs: (word.Empty)
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:old_library) op:Equal rhs:(word.Empty))]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:inherited_linker_flags)
                                  op: Equal
                                  rhs: (word.Empty)
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:installed)
                                  op: Equal
                                  rhs: {(yes)}
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:shouldnotlink)
                                  op: Equal
                                  rhs: {(no)}
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:avoidtemprpath)
                                  op: Equal
                                  rhs: (word.Empty)
                                )
                              ]
                            )
                            (C {(func_source)} {(DQ ($ VSub_DollarName '$lib'))})
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (C {(test)} {(-n)} 
                                          {(DQ ($ VSub_DollarName '$inherited_linker_flags'))}
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:tmp_inherited_linker_flags)
                                          op: Equal
                                          rhs: 
                                            {
                                              (command_sub
                                                left_token: <Left_Backtick '`'>
                                                command_list: 
                                                  (command.CommandList
                                                    children: [
                                                      (command.Pipeline
                                                        children: [
                                                          (C {($ VSub_DollarName '$ECHO')} 
                                                            {
                                                              (DQ 
                                                                ($ VSub_DollarName 
'$inherited_linker_flags'
                                                                )
                                                              )
                                                            }
                                                          )
                                                          (C {($ VSub_DollarName '$SED')} 
                                                            {
                                                              (SQ 
                                                                <
's/-framework \\([^ $]*\\)/\\1.ltframework/g'
                                                                >
                                                              )
                                                            }
                                                          )
                                                        ]
                                                        negated: F
                                                      )
                                                    ]
                                                  )
                                              )
                                            }
                                        )
                                      ]
                                    )
                                    (command.ForEach
                                      iter_name: tmp_inherited_linker_flag
                                      iter_words: [{($ VSub_DollarName '$tmp_inherited_linker_flags')}]
                                      do_arg_iter: F
                                      body: 
                                        (command.DoGroup
                                          children: [
                                            (command.Case
                                              to_match: 
                                                {
                                                  (DQ (' ') 
                                                    ($ VSub_DollarName '$new_inherited_linker_flags') (' ')
                                                  )
                                                }
                                              arms: [
                                                (case_arm
                                                  pat_list: [
                                                    {(Lit_Star '*') 
                                                      (DQ (' ') 
                                                        ($ VSub_DollarName 
'$tmp_inherited_linker_flag'
                                                        ) (' ')
                                                      ) (Lit_Star '*')
                                                    }
                                                  ]
                                                )
                                                (case_arm
                                                  pat_list: [{(Lit_Star '*')}]
                                                  action: [
                                                    (C {(func_append)} {(new_inherited_linker_flags)} 
                                                      {
                                                        (DQ (' ') 
                                                          ($ VSub_DollarName 
'$tmp_inherited_linker_flag'
                                                          )
                                                        )
                                                      }
                                                    )
                                                  ]
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:dependency_libs)
                                  op: Equal
                                  rhs: 
                                    {
                                      (command_sub
                                        left_token: <Left_Backtick '`'>
                                        command_list: 
                                          (command.CommandList
                                            children: [
                                              (command.Pipeline
                                                children: [
                                                  (C {($ VSub_DollarName '$ECHO')} 
                                                    {
                                                      (DQ (' ') ($ VSub_DollarName '$dependency_libs'))
                                                    }
                                                  )
                                                  (C {($ VSub_DollarName '$SED')} 
                                                    {
                                                      (SQ 
                                                        <
's% \\([^ $]*\\).ltframework% -framework \\1%g'
                                                        >
                                                      )
                                                    }
                                                  )
                                                ]
                                                negated: F
                                              )
                                            ]
                                          )
                                      )
                                    }
                                )
                              ]
                            )
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (command.AndOr
                                          ops: [Op_DPipe Op_DPipe]
                                          children: [
                                            (C {(test)} {(lib) (Lit_Comma ',') (link)} 
                                              {(Lit_Equals '=')} {(DQ ($ VSub_DollarName '$linkmode') (',') ($ VSub_DollarName '$pass'))}
                                            )
                                            (C {(test)} {(prog) (Lit_Comma ',') (scan)} 
                                              {(Lit_Equals '=')} {(DQ ($ VSub_DollarName '$linkmode') (',') ($ VSub_DollarName '$pass'))}
                                            )
                                            (command.BraceGroup
                                              children: [
                                                (command.Sentence
                                                  child: 
                                                    (command.AndOr
                                                      ops: [Op_DAmp]
                                                      children: [
                                                        (C {(test)} {(prog)} 
                                                          {(KW_Bang '!') (Lit_Equals '=')} {(DQ ($ VSub_DollarName '$linkmode'))}
                                                        )
                                                        (C {(test)} {(lib)} 
                                                          {(KW_Bang '!') (Lit_Equals '=')} {(DQ ($ VSub_DollarName '$linkmode'))}
                                                        )
                                                      ]
                                                    )
                                                  terminator: <Op_Semi ';'>
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (command.AndOr
                                      ops: [Op_DAmp]
                                      children: [
                                        (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$dlopen'))})
                                        (C {(func_append)} {(dlfiles)} 
                                          {(DQ (' ') ($ VSub_DollarName '$dlopen'))}
                                        )
                                      ]
                                    )
                                    (command.AndOr
                                      ops: [Op_DAmp]
                                      children: [
                                        (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$dlpreopen'))})
                                        (C {(func_append)} {(dlprefiles)} 
                                          {(DQ (' ') ($ VSub_DollarName '$dlpreopen'))}
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (C {(test)} {(conv)} {(Lit_Equals '=')} 
                                          {(DQ ($ VSub_DollarName '$pass'))}
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:deplibs)
                                          op: Equal
                                          rhs: 
                                            {
                                              (DQ ($ VSub_DollarName '$lib') (' ') 
                                                ($ VSub_DollarName '$deplibs')
                                              )
                                            }
                                        )
                                      ]
                                    )
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (command.Sentence
                                              child: 
                                                (C {(test)} {(-z)} {(DQ ($ VSub_DollarName '$libdir'))})
                                              terminator: <Op_Semi ';'>
                                            )
                                          ]
                                          action: [
                                            (command.If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (command.Sentence
                                                      child: 
                                                        (C {(test)} {(-z)} 
                                                          {(DQ ($ VSub_DollarName '$old_library'))}
                                                        )
                                                      terminator: <Op_Semi ';'>
                                                    )
                                                  ]
                                                  action: [
                                                    (C {(func_fatal_error)} 
                                                      {
                                                        (DQ 
                                                          ("cannot find name of link library for '") ($ VSub_DollarName '$lib') ("'")
                                                        )
                                                      }
                                                    )
                                                  ]
                                                )
                                              ]
                                            )
                                            (C {(func_append)} {(convenience)} 
                                              {
                                                (DQ (' ') ($ VSub_DollarName '$ladir') (/) 
                                                  ($ VSub_DollarName '$objdir') (/) ($ VSub_DollarName '$old_library')
                                                )
                                              }
                                            )
                                            (C {(func_append)} {(old_convenience)} 
                                              {
                                                (DQ (' ') ($ VSub_DollarName '$ladir') (/) 
                                                  ($ VSub_DollarName '$objdir') (/) ($ VSub_DollarName '$old_library')
                                                )
                                              }
                                            )
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:tmp_libs)
                                                  op: Equal
                                                  rhs: (word.Empty)
                                                )
                                              ]
                                            )
                                            (command.ForEach
                                              iter_name: deplib
                                              iter_words: [{($ VSub_DollarName '$dependency_libs')}]
                                              do_arg_iter: F
                                              body: 
                                                (command.DoGroup
                                                  children: [
                                                    (command.ShAssignment
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (sh_lhs_expr.Name name:deplibs)
                                                          op: Equal
                                                          rhs: 
                                                            {
                                                              (DQ ($ VSub_DollarName '$deplib') (' ') 
                                                                ($ VSub_DollarName '$deplibs')
                                                              )
                                                            }
                                                        )
                                                      ]
                                                    )
                                                    (command.If
                                                      arms: [
                                                        (if_arm
                                                          cond: [
                                                            (command.Sentence
                                                              child: 
                                                                (C 
                                                                  {
                                                                    ($ VSub_DollarName 
'$opt_preserve_dup_deps'
                                                                    )
                                                                  }
                                                                )
                                                              terminator: <Op_Semi ';'>
                                                            )
                                                          ]
                                                          action: [
                                                            (command.Case
                                                              to_match: 
                                                                {
                                                                  (DQ ($ VSub_DollarName '$tmp_libs') 
                                                                    (' ')
                                                                  )
                                                                }
                                                              arms: [
                                                                (case_arm
                                                                  pat_list: [
                                                                    {(Lit_Star '*') 
                                                                      (DQ (' ') 
                                                                        ($ VSub_DollarName '$deplib') (' ')
                                                                      ) (Lit_Star '*')
                                                                    }
                                                                  ]
                                                                  action: [
                                                                    (C {(func_append)} 
                                                                      {(specialdeplibs)} {(DQ (' ') ($ VSub_DollarName '$deplib'))}
                                                                    )
                                                                  ]
                                                                )
                                                              ]
                                                            )
                                                          ]
                                                        )
                                                      ]
                                                    )
                                                    (C {(func_append)} {(tmp_libs)} 
                                                      {(DQ (' ') ($ VSub_DollarName '$deplib'))}
                                                    )
                                                  ]
                                                )
                                            )
                                          ]
                                        )
                                        (if_arm
                                          cond: [
                                            (command.Sentence
                                              child: 
                                                (command.AndOr
                                                  ops: [Op_DAmp]
                                                  children: [
                                                    (C {(test)} {(prog)} 
                                                      {(KW_Bang '!') (Lit_Equals '=')} {(DQ ($ VSub_DollarName '$linkmode'))}
                                                    )
                                                    (C {(test)} {(lib)} {(KW_Bang '!') (Lit_Equals '=')} 
                                                      {(DQ ($ VSub_DollarName '$linkmode'))}
                                                    )
                                                  ]
                                                )
                                              terminator: <Op_Semi ';'>
                                            )
                                          ]
                                          action: [
                                            (C {(func_fatal_error)} 
                                              {
                                                (DQ ("'") ($ VSub_DollarName '$lib') 
                                                  ("' is not a convenience library")
                                                )
                                              }
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                    (command.ControlFlow
                                      token: <ControlFlow_Continue continue>
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:linklib) op:Equal rhs:(word.Empty))]
                            )
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (command.AndOr
                                          ops: [Op_DAmp]
                                          children: [
                                            (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$old_library'))})
                                            (command.BraceGroup
                                              children: [
                                                (command.Sentence
                                                  child: 
                                                    (command.AndOr
                                                      ops: [Op_DPipe]
                                                      children: [
                                                        (C {(test)} {(yes)} {(Lit_Equals '=')} 
                                                          {
                                                            (DQ 
                                                              ($ VSub_DollarName 
'$prefer_static_libs'
                                                              )
                                                            )
                                                          }
                                                        )
                                                        (C {(test)} {(built) (Lit_Comma ',') (no)} 
                                                          {(Lit_Equals '=')} {(DQ ($ VSub_DollarName '$prefer_static_libs') (',') ($ VSub_DollarName '$installed'))}
                                                        )
                                                      ]
                                                    )
                                                  terminator: <Op_Semi ';'>
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:linklib)
                                          op: Equal
                                          rhs: {($ VSub_DollarName '$old_library')}
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                              else_action: [
                                (command.ForEach
                                  iter_name: l
                                  iter_words: [
                                    {($ VSub_DollarName '$old_library')}
                                    {($ VSub_DollarName '$library_names')}
                                  ]
                                  do_arg_iter: F
                                  body: 
                                    (command.DoGroup
                                      children: [
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:linklib)
                                              op: Equal
                                              rhs: {($ VSub_DollarName '$l')}
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                )
                              ]
                            )
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: (C {(test)} {(-z)} {(DQ ($ VSub_DollarName '$linklib'))})
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (C {(func_fatal_error)} 
                                      {
                                        (DQ ("cannot find name of link library for '") 
                                          ($ VSub_DollarName '$lib') ("'")
                                        )
                                      }
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (C {(test)} {(dlopen)} {(Lit_Equals '=')} 
                                          {(DQ ($ VSub_DollarName '$pass'))}
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (command.AndOr
                                      ops: [Op_DAmp]
                                      children: [
                                        (C {(test)} {(-z)} {(DQ ($ VSub_DollarName '$libdir'))})
                                        (C {(func_fatal_error)} 
                                          {
                                            (DQ ("cannot -dlopen a convenience library: '") 
                                              ($ VSub_DollarName '$lib') ("'")
                                            )
                                          }
                                        )
                                      ]
                                    )
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (command.AndOr
                                              ops: [Op_DPipe Op_DPipe]
                                              children: [
                                                (C {(test)} {(-z)} {(DQ ($ VSub_DollarName '$dlname'))})
                                                (C {(test)} {(yes)} {(KW_Bang '!') (Lit_Equals '=')} 
                                                  {(DQ ($ VSub_DollarName '$dlopen_support'))}
                                                )
                                                (C {(test)} {(no)} {(Lit_Equals '=')} 
                                                  {(DQ ($ VSub_DollarName '$build_libtool_libs'))}
                                                )
                                              ]
                                            )
                                          ]
                                          action: [
                                            (C {(func_append)} {(dlprefiles)} 
                                              {
                                                (DQ (' ') ($ VSub_DollarName '$lib') (' ') 
                                                  ($ VSub_DollarName '$dependency_libs')
                                                )
                                              }
                                            )
                                          ]
                                        )
                                      ]
                                      else_action: [
                                        (C {(func_append)} {(newdlfiles)} 
                                          {(DQ (' ') ($ VSub_DollarName '$lib'))}
                                        )
                                      ]
                                    )
                                    (command.ControlFlow
                                      token: <ControlFlow_Continue continue>
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.Case
                              to_match: {($ VSub_DollarName '$ladir')}
                              arms: [
                                (case_arm
                                  pat_list: [
                                    {(Lit_LBracket '[') 
                                      (word_part.EscapedLiteral
                                        token: <Lit_EscapedChar '\\\\'>
                                      ) (/) (Lit_RBracket ']') (Lit_Star '*')
                                    }
                                    {(Lit_LBracket '[') (A-Za-z) (Lit_RBracket ']') (Lit_Other ':') 
                                      (Lit_LBracket '[') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\\\'>) (/) (Lit_RBracket ']') (Lit_Star '*')
                                    }
                                  ]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:abs_ladir)
                                          op: Equal
                                          rhs: {($ VSub_DollarName '$ladir')}
                                        )
                                      ]
                                    )
                                  ]
                                )
                                (case_arm
                                  pat_list: [{(Lit_Star '*')}]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:abs_ladir)
                                          op: Equal
                                          rhs: 
                                            {
                                              (command_sub
                                                left_token: <Left_Backtick '`'>
                                                command_list: 
                                                  (command.CommandList
                                                    children: [
                                                      (command.AndOr
                                                        ops: [Op_DAmp]
                                                        children: [
                                                          (C {(cd)} {(DQ ($ VSub_DollarName '$ladir'))})
                                                          (C {(pwd)})
                                                        ]
                                                      )
                                                    ]
                                                  )
                                              )
                                            }
                                        )
                                      ]
                                    )
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (command.Sentence
                                              child: 
                                                (C {(test)} {(-z)} 
                                                  {(DQ ($ VSub_DollarName '$abs_ladir'))}
                                                )
                                              terminator: <Op_Semi ';'>
                                            )
                                          ]
                                          action: [
                                            (C {(func_warning)} 
                                              {
                                                (DQ ("cannot determine absolute directory name of '") 
                                                  ($ VSub_DollarName '$ladir') ("'")
                                                )
                                              }
                                            )
                                            (C {(func_warning)} 
                                              {
                                                (DQ 
                                                  (
'passing it literally to the linker, although it might fail'
                                                  )
                                                )
                                              }
                                            )
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:abs_ladir)
                                                  op: Equal
                                                  rhs: {($ VSub_DollarName '$ladir')}
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                            )
                            (C {(func_basename)} {(DQ ($ VSub_DollarName '$lib'))})
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:laname)
                                  op: Equal
                                  rhs: {($ VSub_DollarName '$func_basename_result')}
                                )
                              ]
                            )
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (C {(test)} {(yes)} {(Lit_Equals '=')} 
                                          {(DQ ($ VSub_DollarName '$installed'))}
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (command.Sentence
                                              child: 
                                                (command.AndOr
                                                  ops: [Op_DAmp]
                                                  children: [
                                                    (C {(test)} {(KW_Bang '!')} {(-f)} 
                                                      {
                                                        (DQ ($ VSub_DollarName '$lt_sysroot') 
                                                          ($ VSub_DollarName '$libdir') (/) ($ VSub_DollarName '$linklib')
                                                        )
                                                      }
                                                    )
                                                    (C {(test)} {(-f)} 
                                                      {
                                                        (DQ ($ VSub_DollarName '$abs_ladir') (/) 
                                                          ($ VSub_DollarName '$linklib')
                                                        )
                                                      }
                                                    )
                                                  ]
                                                )
                                              terminator: <Op_Semi ';'>
                                            )
                                          ]
                                          action: [
                                            (C {(func_warning)} 
                                              {
                                                (DQ ("library '") ($ VSub_DollarName '$lib') 
                                                  ("' was moved.")
                                                )
                                              }
                                            )
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:dir)
                                                  op: Equal
                                                  rhs: {($ VSub_DollarName '$ladir')}
                                                )
                                              ]
                                            )
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:absdir)
                                                  op: Equal
                                                  rhs: {($ VSub_DollarName '$abs_ladir')}
                                                )
                                              ]
                                            )
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:libdir)
                                                  op: Equal
                                                  rhs: {($ VSub_DollarName '$abs_ladir')}
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                      ]
                                      else_action: [
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:dir)
                                              op: Equal
                                              rhs: 
                                                {($ VSub_DollarName '$lt_sysroot') 
                                                  ($ VSub_DollarName '$libdir')
                                                }
                                            )
                                          ]
                                        )
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:absdir)
                                              op: Equal
                                              rhs: 
                                                {($ VSub_DollarName '$lt_sysroot') 
                                                  ($ VSub_DollarName '$libdir')
                                                }
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                    (command.AndOr
                                      ops: [Op_DAmp]
                                      children: [
                                        (C {(test)} {(yes)} {(Lit_Equals '=')} 
                                          {(DQ ($ VSub_DollarName '$hardcode_automatic'))}
                                        )
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:avoidtemprpath)
                                              op: Equal
                                              rhs: {(yes)}
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                              else_action: [
                                (command.If
                                  arms: [
                                    (if_arm
                                      cond: [
                                        (command.Sentence
                                          child: 
                                            (command.AndOr
                                              ops: [Op_DAmp]
                                              children: [
                                                (C {(test)} {(KW_Bang '!')} {(-f)} 
                                                  {
                                                    (DQ ($ VSub_DollarName '$ladir') (/) 
                                                      ($ VSub_DollarName '$objdir') (/) ($ VSub_DollarName '$linklib')
                                                    )
                                                  }
                                                )
                                                (C {(test)} {(-f)} 
                                                  {
                                                    (DQ ($ VSub_DollarName '$abs_ladir') (/) 
                                                      ($ VSub_DollarName '$linklib')
                                                    )
                                                  }
                                                )
                                              ]
                                            )
                                          terminator: <Op_Semi ';'>
                                        )
                                      ]
                                      action: [
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:dir)
                                              op: Equal
                                              rhs: {($ VSub_DollarName '$ladir')}
                                            )
                                          ]
                                        )
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:absdir)
                                              op: Equal
                                              rhs: {($ VSub_DollarName '$abs_ladir')}
                                            )
                                          ]
                                        )
                                        (C {(func_append)} {(notinst_path)} 
                                          {(DQ (' ') ($ VSub_DollarName '$abs_ladir'))}
                                        )
                                      ]
                                    )
                                  ]
                                  else_action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:dir)
                                          op: Equal
                                          rhs: 
                                            {($ VSub_DollarName '$ladir') (/) 
                                              ($ VSub_DollarName '$objdir')
                                            }
                                        )
                                      ]
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:absdir)
                                          op: Equal
                                          rhs: 
                                            {($ VSub_DollarName '$abs_ladir') (/) 
                                              ($ VSub_DollarName '$objdir')
                                            }
                                        )
                                      ]
                                    )
                                    (C {(func_append)} {(notinst_path)} 
                                      {(DQ (' ') ($ VSub_DollarName '$abs_ladir'))}
                                    )
                                  ]
                                )
                              ]
                            )
                            (C {(func_stripname)} {(SQ <lib>)} {(SQ <.la>)} 
                              {(DQ ($ VSub_DollarName '$laname'))}
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:name)
                                  op: Equal
                                  rhs: {($ VSub_DollarName '$func_stripname_result')}
                                )
                              ]
                            )
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (C {(test)} {(dlpreopen)} {(Lit_Equals '=')} 
                                          {(DQ ($ VSub_DollarName '$pass'))}
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (command.Sentence
                                              child: 
                                                (command.AndOr
                                                  ops: [Op_DAmp]
                                                  children: [
                                                    (C {(test)} {(-z)} 
                                                      {(DQ ($ VSub_DollarName '$libdir'))}
                                                    )
                                                    (C {(test)} {(prog)} {(Lit_Equals '=')} 
                                                      {(DQ ($ VSub_DollarName '$linkmode'))}
                                                    )
                                                  ]
                                                )
                                              terminator: <Op_Semi ';'>
                                            )
                                          ]
                                          action: [
                                            (C {(func_fatal_error)} 
                                              {
                                                (DQ 
                                                  (
"only libraries may -dlpreopen a convenience library: '"
                                                  ) ($ VSub_DollarName '$lib') ("'")
                                                )
                                              }
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                    (command.Case
                                      to_match: {($ VSub_DollarName '$host')}
                                      arms: [
                                        (case_arm
                                          pat_list: [
                                            {(Lit_Star '*') (cygwin) (Lit_Star '*')}
                                            {(Lit_Star '*') (mingw) (Lit_Star '*')}
                                            {(Lit_Star '*') (cegcc) (Lit_Star '*')}
                                          ]
                                          action: [
                                            (command.If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (command.Sentence
                                                      child: 
                                                        (C {(test)} {(-n)} 
                                                          {(DQ ($ VSub_DollarName '$dlname'))}
                                                        )
                                                      terminator: <Op_Semi ';'>
                                                    )
                                                  ]
                                                  action: [
                                                    (C {(func_tr_sh)} 
                                                      {
                                                        (DQ ($ VSub_DollarName '$dir') (/) 
                                                          ($ VSub_DollarName '$linklib')
                                                        )
                                                      }
                                                    )
                                                    (C {(eval)} 
                                                      {
                                                        (DQ (libfile_) 
                                                          ($ VSub_DollarName '$func_tr_sh_result') ('=') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) (abs_ladir/) 
                                                          (word_part.EscapedLiteral
                                                            token: <Lit_EscapedChar '\\$'>
                                                          ) (laname)
                                                        )
                                                      }
                                                    )
                                                    (C {(func_append)} {(newdlprefiles)} 
                                                      {
                                                        (DQ (' ') ($ VSub_DollarName '$dir') (/) 
                                                          ($ VSub_DollarName '$linklib')
                                                        )
                                                      }
                                                    )
                                                  ]
                                                )
                                              ]
                                              else_action: [
                                                (C {(func_append)} {(newdlprefiles)} 
                                                  {
                                                    (DQ (' ') ($ VSub_DollarName '$dir') (/) 
                                                      ($ VSub_DollarName '$old_library')
                                                    )
                                                  }
                                                )
                                                (command.AndOr
                                                  ops: [Op_DAmp]
                                                  children: [
                                                    (C {(test)} {(-z)} 
                                                      {(DQ ($ VSub_DollarName '$libdir'))}
                                                    )
                                                    (C {(func_append)} {(dlpreconveniencelibs)} 
                                                      {
                                                        (DQ (' ') ($ VSub_DollarName '$dir') (/) 
                                                          ($ VSub_DollarName '$old_library')
                                                        )
                                                      }
                                                    )
                                                  ]
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                        (case_arm
                                          pat_list: [{(Lit_Star '*')}]
                                          action: [
                                            (command.If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (command.Sentence
                                                      child: 
                                                        (C {(test)} {(-n)} 
                                                          {(DQ ($ VSub_DollarName '$old_library'))}
                                                        )
                                                      terminator: <Op_Semi ';'>
                                                    )
                                                  ]
                                                  action: [
                                                    (C {(func_append)} {(newdlprefiles)} 
                                                      {
                                                        (DQ (' ') ($ VSub_DollarName '$dir') (/) 
                                                          ($ VSub_DollarName '$old_library')
                                                        )
                                                      }
                                                    )
                                                    (command.AndOr
                                                      ops: [Op_DAmp]
                                                      children: [
                                                        (C {(test)} {(-z)} 
                                                          {(DQ ($ VSub_DollarName '$libdir'))}
                                                        )
                                                        (C {(func_append)} {(dlpreconveniencelibs)} 
                                                          {
                                                            (DQ (' ') ($ VSub_DollarName '$dir') (/) 
                                                              ($ VSub_DollarName '$old_library')
                                                            )
                                                          }
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                )
                                                (if_arm
                                                  cond: [
                                                    (command.Sentence
                                                      child: 
                                                        (C {(test)} {(-n)} 
                                                          {(DQ ($ VSub_DollarName '$dlname'))}
                                                        )
                                                      terminator: <Op_Semi ';'>
                                                    )
                                                  ]
                                                  action: [
                                                    (C {(func_append)} {(newdlprefiles)} 
                                                      {
                                                        (DQ (' ') ($ VSub_DollarName '$dir') (/) 
                                                          ($ VSub_DollarName '$dlname')
                                                        )
                                                      }
                                                    )
                                                  ]
                                                )
                                              ]
                                              else_action: [
                                                (C {(func_append)} {(newdlprefiles)} 
                                                  {
                                                    (DQ (' ') ($ VSub_DollarName '$dir') (/) 
                                                      ($ VSub_DollarName '$linklib')
                                                    )
                                                  }
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: (C {(test)} {(-z)} {(DQ ($ VSub_DollarName '$libdir'))})
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (command.Sentence
                                              child: 
                                                (C {(test)} {(lib)} {(Lit_Equals '=')} 
                                                  {(DQ ($ VSub_DollarName '$linkmode'))}
                                                )
                                              terminator: <Op_Semi ';'>
                                            )
                                          ]
                                          action: [
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:deplibs)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ ($ VSub_DollarName '$dir') (/) 
                                                        ($ VSub_DollarName '$old_library') (' ') ($ VSub_DollarName '$deplibs')
                                                      )
                                                    }
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                        (if_arm
                                          cond: [
                                            (command.Sentence
                                              child: 
                                                (C {(test)} {(prog) (Lit_Comma ',') (link)} 
                                                  {(Lit_Equals '=')} {(DQ ($ VSub_DollarName '$linkmode') (',') ($ VSub_DollarName '$pass'))}
                                                )
                                              terminator: <Op_Semi ';'>
                                            )
                                          ]
                                          action: [
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:compile_deplibs)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ ($ VSub_DollarName '$dir') (/) 
                                                        ($ VSub_DollarName '$old_library') (' ') ($ VSub_DollarName '$compile_deplibs')
                                                      )
                                                    }
                                                )
                                              ]
                                            )
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:finalize_deplibs)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ ($ VSub_DollarName '$dir') (/) 
                                                        ($ VSub_DollarName '$old_library') (' ') ($ VSub_DollarName '$finalize_deplibs')
                                                      )
                                                    }
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                      ]
                                      else_action: [
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:deplibs)
                                              op: Equal
                                              rhs: 
                                                {
                                                  (DQ ($ VSub_DollarName '$lib') (' ') 
                                                    ($ VSub_DollarName '$deplibs')
                                                  )
                                                }
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                    (command.ControlFlow
                                      token: <ControlFlow_Continue continue>
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (command.AndOr
                                          ops: [Op_DAmp]
                                          children: [
                                            (C {(test)} {(prog)} {(Lit_Equals '=')} 
                                              {(DQ ($ VSub_DollarName '$linkmode'))}
                                            )
                                            (C {(test)} {(link)} {(KW_Bang '!') (Lit_Equals '=')} 
                                              {(DQ ($ VSub_DollarName '$pass'))}
                                            )
                                          ]
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (C {(func_append)} {(newlib_search_path)} 
                                      {(DQ (' ') ($ VSub_DollarName '$ladir'))}
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:deplibs)
                                          op: Equal
                                          rhs: 
                                            {
                                              (DQ ($ VSub_DollarName '$lib') (' ') 
                                                ($ VSub_DollarName '$deplibs')
                                              )
                                            }
                                        )
                                      ]
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:linkalldeplibs)
                                          op: Equal
                                          rhs: {(false)}
                                        )
                                      ]
                                    )
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (command.Sentence
                                              child: 
                                                (command.AndOr
                                                  ops: [Op_DPipe Op_DPipe]
                                                  children: [
                                                    (C {(test)} {(no)} {(KW_Bang '!') (Lit_Equals '=')} 
                                                      {(DQ ($ VSub_DollarName '$link_all_deplibs'))}
                                                    )
                                                    (C {(test)} {(-z)} 
                                                      {(DQ ($ VSub_DollarName '$library_names'))}
                                                    )
                                                    (C {(test)} {(no)} {(Lit_Equals '=')} 
                                                      {(DQ ($ VSub_DollarName '$build_libtool_libs'))}
                                                    )
                                                  ]
                                                )
                                              terminator: <Op_Semi ';'>
                                            )
                                          ]
                                          action: [
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:linkalldeplibs)
                                                  op: Equal
                                                  rhs: {(Lit_Other ':')}
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:tmp_libs)
                                          op: Equal
                                          rhs: (word.Empty)
                                        )
                                      ]
                                    )
                                    (command.ForEach
                                      iter_name: deplib
                                      iter_words: [{($ VSub_DollarName '$dependency_libs')}]
                                      do_arg_iter: F
                                      body: 
                                        (command.DoGroup
                                          children: [
                                            (command.Case
                                              to_match: {($ VSub_DollarName '$deplib')}
                                              arms: [
                                                (case_arm
                                                  pat_list: [{(-L) (Lit_Star '*')}]
                                                  action: [
                                                    (C {(func_stripname)} {(SQ <-L>)} {(SQ )} 
                                                      {(DQ ($ VSub_DollarName '$deplib'))}
                                                    )
                                                    (C {(func_resolve_sysroot)} 
                                                      {
                                                        (DQ 
                                                          ($ VSub_DollarName '$func_stripname_result')
                                                        )
                                                      }
                                                    )
                                                    (C {(func_append)} {(newlib_search_path)} 
                                                      {
                                                        (DQ (' ') 
                                                          ($ VSub_DollarName 
'$func_resolve_sysroot_result'
                                                          )
                                                        )
                                                      }
                                                    )
                                                  ]
                                                )
                                              ]
                                            )
                                            (command.If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (command.Sentence
                                                      child: 
                                                        (C {($ VSub_DollarName '$linkalldeplibs')})
                                                      terminator: <Op_Semi ';'>
                                                    )
                                                  ]
                                                  action: [
                                                    (command.ShAssignment
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (sh_lhs_expr.Name name:deplibs)
                                                          op: Equal
                                                          rhs: 
                                                            {
                                                              (DQ ($ VSub_DollarName '$deplib') (' ') 
                                                                ($ VSub_DollarName '$deplibs')
                                                              )
                                                            }
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                )
                                              ]
                                              else_action: [
                                                (command.ShAssignment
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (sh_lhs_expr.Name name:newdependency_libs)
                                                      op: Equal
                                                      rhs: 
                                                        {
                                                          (DQ ($ VSub_DollarName '$deplib') (' ') 
                                                            ($ VSub_DollarName '$newdependency_libs')
                                                          )
                                                        }
                                                    )
                                                  ]
                                                )
                                              ]
                                            )
                                            (command.If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (command.Sentence
                                                      child: 
                                                        (C 
                                                          {
                                                            ($ VSub_DollarName 
'$opt_preserve_dup_deps'
                                                            )
                                                          }
                                                        )
                                                      terminator: <Op_Semi ';'>
                                                    )
                                                  ]
                                                  action: [
                                                    (command.Case
                                                      to_match: 
                                                        {(DQ ($ VSub_DollarName '$tmp_libs') (' '))}
                                                      arms: [
                                                        (case_arm
                                                          pat_list: [
                                                            {(Lit_Star '*') 
                                                              (DQ (' ') ($ VSub_DollarName '$deplib') 
                                                                (' ')
                                                              ) (Lit_Star '*')
                                                            }
                                                          ]
                                                          action: [
                                                            (C {(func_append)} {(specialdeplibs)} 
                                                              {
                                                                (DQ (' ') 
                                                                  ($ VSub_DollarName '$deplib')
                                                                )
                                                              }
                                                            )
                                                          ]
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                )
                                              ]
                                            )
                                            (C {(func_append)} {(tmp_libs)} 
                                              {(DQ (' ') ($ VSub_DollarName '$deplib'))}
                                            )
                                          ]
                                        )
                                    )
                                    (command.ControlFlow
                                      token: <ControlFlow_Continue continue>
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (C {(test)} {(prog) (Lit_Comma ',') (link)} {(Lit_Equals '=')} 
                                          {
                                            (DQ ($ VSub_DollarName '$linkmode') (',') 
                                              ($ VSub_DollarName '$pass')
                                            )
                                          }
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (command.Sentence
                                              child: 
                                                (command.AndOr
                                                  ops: [Op_DAmp]
                                                  children: [
                                                    (C {(test)} {(-n)} 
                                                      {(DQ ($ VSub_DollarName '$library_names'))}
                                                    )
                                                    (command.BraceGroup
                                                      children: [
                                                        (command.Sentence
                                                          child: 
                                                            (command.AndOr
                                                              ops: [Op_DPipe]
                                                              children: [
                                                                (command.BraceGroup
                                                                  children: [
                                                                    (command.Sentence
                                                                      child: 
                                                                        (command.AndOr
                                                                          ops: [Op_DPipe]
                                                                          children: [
                                                                            (C {(test)} {(no)} 
                                                                              {(Lit_Equals '=')} {(DQ ($ VSub_DollarName '$prefer_static_libs'))}
                                                                            )
                                                                            (C {(test)} 
                                                                              {(built) 
                                                                                (Lit_Comma ',') (yes)
                                                                              } {(Lit_Equals '=')} 
                                                                              {
                                                                                (DQ 
                                                                                  ($ VSub_DollarName 
'$prefer_static_libs'
                                                                                  ) (',') ($ VSub_DollarName '$installed')
                                                                                )
                                                                              }
                                                                            )
                                                                          ]
                                                                        )
                                                                      terminator: <Op_Semi ';'>
                                                                    )
                                                                  ]
                                                                )
                                                                (C {(test)} {(-z)} 
                                                                  {
                                                                    (DQ 
                                                                      ($ VSub_DollarName 
'$old_library'
                                                                      )
                                                                    )
                                                                  }
                                                                )
                                                              ]
                                                            )
                                                          terminator: <Op_Semi ';'>
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                )
                                              terminator: <Op_Semi ';'>
                                            )
                                          ]
                                          action: [
                                            (command.If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (command.Sentence
                                                      child: 
                                                        (command.AndOr
                                                          ops: [Op_DAmp]
                                                          children: [
                                                            (C {(test)} {(-n)} 
                                                              {
                                                                (DQ 
                                                                  ($ VSub_DollarName '$shlibpath_var')
                                                                )
                                                              }
                                                            )
                                                            (C {(test)} {(-z)} 
                                                              {
                                                                (DQ 
                                                                  ($ VSub_DollarName 
'$avoidtemprpath'
                                                                  )
                                                                )
                                                              }
                                                            )
                                                          ]
                                                        )
                                                      terminator: <Op_Semi ';'>
                                                    )
                                                  ]
                                                  action: [
                                                    (command.Case
                                                      to_match: 
                                                        {($ VSub_DollarName '$temp_rpath') 
                                                          (Lit_Other ':')
                                                        }
                                                      arms: [
                                                        (case_arm
                                                          pat_list: [
                                                            {(Lit_Star '*') 
                                                              (DQ ($ VSub_DollarName '$absdir') (':')) (Lit_Star '*')
                                                            }
                                                          ]
                                                        )
                                                        (case_arm
                                                          pat_list: [{(Lit_Star '*')}]
                                                          action: [
                                                            (C {(func_append)} {(temp_rpath)} 
                                                              {
                                                                (DQ ($ VSub_DollarName '$absdir') 
                                                                  (':')
                                                                )
                                                              }
                                                            )
                                                          ]
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                )
                                              ]
                                            )
                                            (command.Case
                                              to_match: 
                                                {
                                                  (DQ (' ') 
                                                    ($ VSub_DollarName '$sys_lib_dlsearch_path') (' ')
                                                  )
                                                }
                                              arms: [
                                                (case_arm
                                                  pat_list: [
                                                    {(Lit_Star '*') 
                                                      (DQ (' ') ($ VSub_DollarName '$absdir') (' ')) (Lit_Star '*')
                                                    }
                                                  ]
                                                )
                                                (case_arm
                                                  pat_list: [{(Lit_Star '*')}]
                                                  action: [
                                                    (command.Case
                                                      to_match: 
                                                        {
                                                          (DQ ($ VSub_DollarName '$compile_rpath') 
                                                            (' ')
                                                          )
                                                        }
                                                      arms: [
                                                        (case_arm
                                                          pat_list: [
                                                            {(Lit_Star '*') 
                                                              (DQ (' ') ($ VSub_DollarName '$absdir') 
                                                                (' ')
                                                              ) (Lit_Star '*')
                                                            }
                                                          ]
                                                        )
                                                        (case_arm
                                                          pat_list: [{(Lit_Star '*')}]
                                                          action: [
                                                            (C {(func_append)} {(compile_rpath)} 
                                                              {
                                                                (DQ (' ') 
                                                                  ($ VSub_DollarName '$absdir')
                                                                )
                                                              }
                                                            )
                                                          ]
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                )
                                              ]
                                            )
                                            (command.Case
                                              to_match: 
                                                {
                                                  (DQ (' ') 
                                                    ($ VSub_DollarName '$sys_lib_dlsearch_path') (' ')
                                                  )
                                                }
                                              arms: [
                                                (case_arm
                                                  pat_list: [
                                                    {(Lit_Star '*') 
                                                      (DQ (' ') ($ VSub_DollarName '$libdir') (' ')) (Lit_Star '*')
                                                    }
                                                  ]
                                                )
                                                (case_arm
                                                  pat_list: [{(Lit_Star '*')}]
                                                  action: [
                                                    (command.Case
                                                      to_match: 
                                                        {
                                                          (DQ ($ VSub_DollarName '$finalize_rpath') 
                                                            (' ')
                                                          )
                                                        }
                                                      arms: [
                                                        (case_arm
                                                          pat_list: [
                                                            {(Lit_Star '*') 
                                                              (DQ (' ') ($ VSub_DollarName '$libdir') 
                                                                (' ')
                                                              ) (Lit_Star '*')
                                                            }
                                                          ]
                                                        )
                                                        (case_arm
                                                          pat_list: [{(Lit_Star '*')}]
                                                          action: [
                                                            (C {(func_append)} {(finalize_rpath)} 
                                                              {
                                                                (DQ (' ') 
                                                                  ($ VSub_DollarName '$libdir')
                                                                )
                                                              }
                                                            )
                                                          ]
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (command.Sentence
                                              child: 
                                                (command.AndOr
                                                  ops: [Op_DAmp]
                                                  children: [
                                                    (C {($ VSub_DollarName '$alldeplibs')})
                                                    (command.BraceGroup
                                                      children: [
                                                        (command.Sentence
                                                          child: 
                                                            (command.AndOr
                                                              ops: [Op_DPipe]
                                                              children: [
                                                                (C {(test)} {(pass_all)} 
                                                                  {(Lit_Equals '=')} {(DQ ($ VSub_DollarName '$deplibs_check_method'))}
                                                                )
                                                                (command.BraceGroup
                                                                  children: [
                                                                    (command.Sentence
                                                                      child: 
                                                                        (command.AndOr
                                                                          ops: [Op_DAmp]
                                                                          children: [
                                                                            (C {(test)} {(yes)} 
                                                                              {(Lit_Equals '=')} {(DQ ($ VSub_DollarName '$build_libtool_libs'))}
                                                                            )
                                                                            (C {(test)} {(-n)} 
                                                                              {
                                                                                (DQ 
                                                                                  ($ VSub_DollarName 
'$library_names'
                                                                                  )
                                                                                )
                                                                              }
                                                                            )
                                                                          ]
                                                                        )
                                                                      terminator: <Op_Semi ';'>
                                                                    )
                                                                  ]
                                                                )
                                                              ]
                                                            )
                                                          terminator: <Op_Semi ';'>
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                )
                                              terminator: <Op_Semi ';'>
                                            )
                                          ]
                                          action: [
                                            (command.ControlFlow
                                              token: <ControlFlow_Continue continue>
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:link_static)
                                  op: Equal
                                  rhs: {(no)}
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:use_static_libs)
                                  op: Equal
                                  rhs: {($ VSub_DollarName '$prefer_static_libs')}
                                )
                              ]
                            )
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (command.AndOr
                                          ops: [Op_DAmp]
                                          children: [
                                            (C {(test)} {(built)} {(Lit_Equals '=')} 
                                              {(DQ ($ VSub_DollarName '$use_static_libs'))}
                                            )
                                            (C {(test)} {(yes)} {(Lit_Equals '=')} 
                                              {(DQ ($ VSub_DollarName '$installed'))}
                                            )
                                          ]
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:use_static_libs)
                                          op: Equal
                                          rhs: {(no)}
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (command.AndOr
                                          ops: [Op_DAmp]
                                          children: [
                                            (C {(test)} {(-n)} 
                                              {(DQ ($ VSub_DollarName '$library_names'))}
                                            )
                                            (command.BraceGroup
                                              children: [
                                                (command.Sentence
                                                  child: 
                                                    (command.AndOr
                                                      ops: [Op_DPipe]
                                                      children: [
                                                        (C {(test)} {(no)} {(Lit_Equals '=')} 
                                                          {
                                                            (DQ 
                                                              ($ VSub_DollarName '$use_static_libs')
                                                            )
                                                          }
                                                        )
                                                        (C {(test)} {(-z)} 
                                                          {(DQ ($ VSub_DollarName '$old_library'))}
                                                        )
                                                      ]
                                                    )
                                                  terminator: <Op_Semi ';'>
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (command.Case
                                      to_match: {($ VSub_DollarName '$host')}
                                      arms: [
                                        (case_arm
                                          pat_list: [
                                            {(Lit_Star '*') (cygwin) (Lit_Star '*')}
                                            {(Lit_Star '*') (mingw) (Lit_Star '*')}
                                            {(Lit_Star '*') (cegcc) (Lit_Star '*')}
                                            {(Lit_Star '*') (os2) (Lit_Star '*')}
                                          ]
                                          action: [
                                            (C {(func_append)} {(notinst_deplibs)} 
                                              {(DQ (' ') ($ VSub_DollarName '$lib'))}
                                            )
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:need_relink)
                                                  op: Equal
                                                  rhs: {(no)}
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                        (case_arm
                                          pat_list: [{(Lit_Star '*')}]
                                          action: [
                                            (command.If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (command.Sentence
                                                      child: 
                                                        (C {(test)} {(no)} {(Lit_Equals '=')} 
                                                          {(DQ ($ VSub_DollarName '$installed'))}
                                                        )
                                                      terminator: <Op_Semi ';'>
                                                    )
                                                  ]
                                                  action: [
                                                    (C {(func_append)} {(notinst_deplibs)} 
                                                      {(DQ (' ') ($ VSub_DollarName '$lib'))}
                                                    )
                                                    (command.ShAssignment
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (sh_lhs_expr.Name name:need_relink)
                                                          op: Equal
                                                          rhs: {(yes)}
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:dlopenmodule)
                                          op: Equal
                                          rhs: (word.Empty)
                                        )
                                      ]
                                    )
                                    (command.ForEach
                                      iter_name: dlpremoduletest
                                      iter_words: [{($ VSub_DollarName '$dlprefiles')}]
                                      do_arg_iter: F
                                      body: 
                                        (command.DoGroup
                                          children: [
                                            (command.If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (command.Sentence
                                                      child: 
                                                        (C {(test)} 
                                                          {
                                                            (DQ (X) 
                                                              ($ VSub_DollarName '$dlpremoduletest')
                                                            )
                                                          } {(Lit_Equals '=')} {(DQ (X) ($ VSub_DollarName '$lib'))}
                                                        )
                                                      terminator: <Op_Semi ';'>
                                                    )
                                                  ]
                                                  action: [
                                                    (command.ShAssignment
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (sh_lhs_expr.Name name:dlopenmodule)
                                                          op: Equal
                                                          rhs: 
                                                            {($ VSub_DollarName '$dlpremoduletest')}
                                                        )
                                                      ]
                                                    )
                                                    (command.ControlFlow
                                                      token: <ControlFlow_Break break>
                                                    )
                                                  ]
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                    )
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (command.Sentence
                                              child: 
                                                (command.AndOr
                                                  ops: [Op_DAmp Op_DAmp]
                                                  children: [
                                                    (C {(test)} {(-z)} 
                                                      {(DQ ($ VSub_DollarName '$dlopenmodule'))}
                                                    )
                                                    (C {(test)} {(yes)} {(Lit_Equals '=')} 
                                                      {(DQ ($ VSub_DollarName '$shouldnotlink'))}
                                                    )
                                                    (C {(test)} {(link)} {(Lit_Equals '=')} 
                                                      {(DQ ($ VSub_DollarName '$pass'))}
                                                    )
                                                  ]
                                                )
                                              terminator: <Op_Semi ';'>
                                            )
                                          ]
                                          action: [
                                            (C {(echo)})
                                            (command.If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (command.Sentence
                                                      child: 
                                                        (C {(test)} {(prog)} {(Lit_Equals '=')} 
                                                          {(DQ ($ VSub_DollarName '$linkmode'))}
                                                        )
                                                      terminator: <Op_Semi ';'>
                                                    )
                                                  ]
                                                  action: [
                                                    (C {($ VSub_DollarName '$ECHO')} 
                                                      {
                                                        (DQ ('*** Warning: Linking the executable ') 
                                                          ($ VSub_DollarName '$output') (' against the loadable module')
                                                        )
                                                      }
                                                    )
                                                  ]
                                                )
                                              ]
                                              else_action: [
                                                (C {($ VSub_DollarName '$ECHO')} 
                                                  {
                                                    (DQ ('*** Warning: Linking the shared library ') 
                                                      ($ VSub_DollarName '$output') (' against the loadable module')
                                                    )
                                                  }
                                                )
                                              ]
                                            )
                                            (C {($ VSub_DollarName '$ECHO')} 
                                              {
                                                (DQ ('*** ') ($ VSub_DollarName '$linklib') 
                                                  (' is not portable!')
                                                )
                                              }
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (command.Sentence
                                              child: 
                                                (command.AndOr
                                                  ops: [Op_DAmp]
                                                  children: [
                                                    (C {(test)} {(lib)} {(Lit_Equals '=')} 
                                                      {(DQ ($ VSub_DollarName '$linkmode'))}
                                                    )
                                                    (C {(test)} {(yes)} {(Lit_Equals '=')} 
                                                      {(DQ ($ VSub_DollarName '$hardcode_into_libs'))}
                                                    )
                                                  ]
                                                )
                                              terminator: <Op_Semi ';'>
                                            )
                                          ]
                                          action: [
                                            (command.Case
                                              to_match: 
                                                {
                                                  (DQ (' ') 
                                                    ($ VSub_DollarName '$sys_lib_dlsearch_path') (' ')
                                                  )
                                                }
                                              arms: [
                                                (case_arm
                                                  pat_list: [
                                                    {(Lit_Star '*') 
                                                      (DQ (' ') ($ VSub_DollarName '$absdir') (' ')) (Lit_Star '*')
                                                    }
                                                  ]
                                                )
                                                (case_arm
                                                  pat_list: [{(Lit_Star '*')}]
                                                  action: [
                                                    (command.Case
                                                      to_match: 
                                                        {
                                                          (DQ ($ VSub_DollarName '$compile_rpath') 
                                                            (' ')
                                                          )
                                                        }
                                                      arms: [
                                                        (case_arm
                                                          pat_list: [
                                                            {(Lit_Star '*') 
                                                              (DQ (' ') ($ VSub_DollarName '$absdir') 
                                                                (' ')
                                                              ) (Lit_Star '*')
                                                            }
                                                          ]
                                                        )
                                                        (case_arm
                                                          pat_list: [{(Lit_Star '*')}]
                                                          action: [
                                                            (C {(func_append)} {(compile_rpath)} 
                                                              {
                                                                (DQ (' ') 
                                                                  ($ VSub_DollarName '$absdir')
                                                                )
                                                              }
                                                            )
                                                          ]
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                )
                                              ]
                                            )
                                            (command.Case
                                              to_match: 
                                                {
                                                  (DQ (' ') 
                                                    ($ VSub_DollarName '$sys_lib_dlsearch_path') (' ')
                                                  )
                                                }
                                              arms: [
                                                (case_arm
                                                  pat_list: [
                                                    {(Lit_Star '*') 
                                                      (DQ (' ') ($ VSub_DollarName '$libdir') (' ')) (Lit_Star '*')
                                                    }
                                                  ]
                                                )
                                                (case_arm
                                                  pat_list: [{(Lit_Star '*')}]
                                                  action: [
                                                    (command.Case
                                                      to_match: 
                                                        {
                                                          (DQ ($ VSub_DollarName '$finalize_rpath') 
                                                            (' ')
                                                          )
                                                        }
                                                      arms: [
                                                        (case_arm
                                                          pat_list: [
                                                            {(Lit_Star '*') 
                                                              (DQ (' ') ($ VSub_DollarName '$libdir') 
                                                                (' ')
                                                              ) (Lit_Star '*')
                                                            }
                                                          ]
                                                        )
                                                        (case_arm
                                                          pat_list: [{(Lit_Star '*')}]
                                                          action: [
                                                            (C {(func_append)} {(finalize_rpath)} 
                                                              {
                                                                (DQ (' ') 
                                                                  ($ VSub_DollarName '$libdir')
                                                                )
                                                              }
                                                            )
                                                          ]
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (command.Sentence
                                              child: 
                                                (C {(test)} {(-n)} 
                                                  {
                                                    (DQ 
                                                      ($ VSub_DollarName 
'$old_archive_from_expsyms_cmds'
                                                      )
                                                    )
                                                  }
                                                )
                                              terminator: <Op_Semi ';'>
                                            )
                                          ]
                                          action: [
                                            (C {(KW_Set set)} {(dummy)} 
                                              {($ VSub_DollarName '$library_names')}
                                            )
                                            (C {(shift)})
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:realname)
                                                  op: Equal
                                                  rhs: {($ VSub_Number '$1')}
                                                )
                                              ]
                                            )
                                            (C {(shift)})
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:libname)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (command_sub
                                                        left_token: <Left_Backtick '`'>
                                                        command_list: 
                                                          (command.CommandList
                                                            children: [
                                                              (C {(eval)} 
                                                                {
                                                                  (DQ 
                                                                    (word_part.EscapedLiteral
                                                                      token: <Lit_EscapedChar '\\$'>
                                                                    ) ('ECHO ')
                                                                  ) ($ VSub_DollarName '$libname_spec') (DQ )
                                                                }
                                                              )
                                                            ]
                                                          )
                                                      )
                                                    }
                                                )
                                              ]
                                            )
                                            (command.If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (command.Sentence
                                                      child: 
                                                        (C {(test)} {(-n)} 
                                                          {(DQ ($ VSub_DollarName '$dlname'))}
                                                        )
                                                      terminator: <Op_Semi ';'>
                                                    )
                                                  ]
                                                  action: [
                                                    (command.ShAssignment
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (sh_lhs_expr.Name name:soname)
                                                          op: Equal
                                                          rhs: {($ VSub_DollarName '$dlname')}
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                )
                                                (if_arm
                                                  cond: [
                                                    (command.Sentence
                                                      child: 
                                                        (C {(test)} {(-n)} 
                                                          {(DQ ($ VSub_DollarName '$soname_spec'))}
                                                        )
                                                      terminator: <Op_Semi ';'>
                                                    )
                                                  ]
                                                  action: [
                                                    (command.Case
                                                      to_match: {($ VSub_DollarName '$host')}
                                                      arms: [
                                                        (case_arm
                                                          pat_list: [
                                                            {(Lit_Star '*') (cygwin) (Lit_Star '*')}
                                                            {(mingw) (Lit_Star '*')}
                                                            {(Lit_Star '*') (cegcc) (Lit_Star '*')}
                                                            {(Lit_Star '*') (os2) (Lit_Star '*')}
                                                          ]
                                                          action: [
                                                            (C {(func_arith)} 
                                                              {($ VSub_DollarName '$current')} {(-)} {($ VSub_DollarName '$age')}
                                                            )
                                                            (command.ShAssignment
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: (sh_lhs_expr.Name name:major)
                                                                  op: Equal
                                                                  rhs: 
                                                                    {
                                                                      ($ VSub_DollarName 
'$func_arith_result'
                                                                      )
                                                                    }
                                                                )
                                                              ]
                                                            )
                                                            (command.ShAssignment
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: 
                                                                    (sh_lhs_expr.Name
                                                                      name: versuffix
                                                                    )
                                                                  op: Equal
                                                                  rhs: 
                                                                    {(-) ($ VSub_DollarName '$major')}
                                                                )
                                                              ]
                                                            )
                                                          ]
                                                        )
                                                      ]
                                                    )
                                                    (C {(eval)} 
                                                      {(Lit_VarLike 'soname=') 
                                                        (word_part.EscapedLiteral
                                                          token: <Lit_EscapedChar '\\"'>
                                                        ) ($ VSub_DollarName '$soname_spec') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>)
                                                      }
                                                    )
                                                  ]
                                                )
                                              ]
                                              else_action: [
                                                (command.ShAssignment
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (sh_lhs_expr.Name name:soname)
                                                      op: Equal
                                                      rhs: {($ VSub_DollarName '$realname')}
                                                    )
                                                  ]
                                                )
                                              ]
                                            )
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:soroot)
                                                  op: Equal
                                                  rhs: {($ VSub_DollarName '$soname')}
                                                )
                                              ]
                                            )
                                            (C {(func_basename)} {(DQ ($ VSub_DollarName '$soroot'))})
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:soname)
                                                  op: Equal
                                                  rhs: {($ VSub_DollarName '$func_basename_result')}
                                                )
                                              ]
                                            )
                                            (C {(func_stripname)} {(SQ <lib>)} {(SQ <.dll>)} 
                                              {(DQ ($ VSub_DollarName '$soname'))}
                                            )
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:newlib)
                                                  op: Equal
                                                  rhs: 
                                                    {(libimp-) 
                                                      ($ VSub_DollarName '$func_stripname_result') (.a)
                                                    }
                                                )
                                              ]
                                            )
                                            (command.If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (command.Sentence
                                                      child: 
                                                        (C {(test)} {(-f)} 
                                                          {
                                                            (DQ ($ VSub_DollarName '$output_objdir') 
                                                              (/) ($ VSub_DollarName '$soname') (-def)
                                                            )
                                                          }
                                                        )
                                                      terminator: <Op_Semi ';'>
                                                    )
                                                  ]
                                                  action: [(C {(Lit_Other ':')})]
                                                )
                                              ]
                                              else_action: [
                                                (C {(func_verbose)} 
                                                  {
                                                    (DQ ("extracting exported symbol list from '") 
                                                      ($ VSub_DollarName '$soname') ("'")
                                                    )
                                                  }
                                                )
                                                (C {(func_execute_cmds)} 
                                                  {(DQ ($ VSub_DollarName '$extract_expsyms_cmds'))} {(SQ <'exit $?'>)}
                                                )
                                              ]
                                            )
                                            (command.If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (command.Sentence
                                                      child: 
                                                        (C {(test)} {(-f)} 
                                                          {
                                                            (DQ ($ VSub_DollarName '$output_objdir') 
                                                              (/) ($ VSub_DollarName '$newlib')
                                                            )
                                                          }
                                                        )
                                                      terminator: <Op_Semi ';'>
                                                    )
                                                  ]
                                                  action: [
                                                    (command.Sentence
                                                      child: (C {(Lit_Other ':')})
                                                      terminator: <Op_Semi ';'>
                                                    )
                                                  ]
                                                )
                                              ]
                                              else_action: [
                                                (C {(func_verbose)} 
                                                  {
                                                    (DQ ("generating import library for '") 
                                                      ($ VSub_DollarName '$soname') ("'")
                                                    )
                                                  }
                                                )
                                                (C {(func_execute_cmds)} 
                                                  {
                                                    (DQ 
                                                      ($ VSub_DollarName 
'$old_archive_from_expsyms_cmds'
                                                      )
                                                    )
                                                  } {(SQ <'exit $?'>)}
                                                )
                                              ]
                                            )
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:dir)
                                                  op: Equal
                                                  rhs: {($ VSub_DollarName '$output_objdir')}
                                                )
                                              ]
                                            )
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:linklib)
                                                  op: Equal
                                                  rhs: {($ VSub_DollarName '$newlib')}
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (command.Sentence
                                              child: 
                                                (command.AndOr
                                                  ops: [Op_DPipe]
                                                  children: [
                                                    (C {(test)} {(prog)} {(Lit_Equals '=')} 
                                                      {(DQ ($ VSub_DollarName '$linkmode'))}
                                                    )
                                                    (C {(test)} {(relink)} 
                                                      {(KW_Bang '!') (Lit_Equals '=')} {(DQ ($ VSub_DollarName '$opt_mode'))}
                                                    )
                                                  ]
                                                )
                                              terminator: <Op_Semi ';'>
                                            )
                                          ]
                                          action: [
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:add_shlibpath)
                                                  op: Equal
                                                  rhs: (word.Empty)
                                                )
                                              ]
                                            )
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:add_dir)
                                                  op: Equal
                                                  rhs: (word.Empty)
                                                )
                                              ]
                                            )
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:add)
                                                  op: Equal
                                                  rhs: (word.Empty)
                                                )
                                              ]
                                            )
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:lib_linked)
                                                  op: Equal
                                                  rhs: {(yes)}
                                                )
                                              ]
                                            )
                                            (command.Case
                                              to_match: {($ VSub_DollarName '$hardcode_action')}
                                              arms: [
                                                (case_arm
                                                  pat_list: [{(immediate)} {(unsupported)}]
                                                  action: [
                                                    (command.If
                                                      arms: [
                                                        (if_arm
                                                          cond: [
                                                            (command.Sentence
                                                              child: 
                                                                (C {(test)} {(no)} {(Lit_Equals '=')} 
                                                                  {
                                                                    (DQ 
                                                                      ($ VSub_DollarName 
'$hardcode_direct'
                                                                      )
                                                                    )
                                                                  }
                                                                )
                                                              terminator: <Op_Semi ';'>
                                                            )
                                                          ]
                                                          action: [
                                                            (command.ShAssignment
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: (sh_lhs_expr.Name name:add)
                                                                  op: Equal
                                                                  rhs: 
                                                                    {($ VSub_DollarName '$dir') (/) 
                                                                      ($ VSub_DollarName '$linklib')
                                                                    }
                                                                )
                                                              ]
                                                            )
                                                            (command.Case
                                                              to_match: {($ VSub_DollarName '$host')}
                                                              arms: [
                                                                (case_arm
                                                                  pat_list: [
                                                                    {(Lit_Star '*') (-) (Lit_Star '*') 
                                                                      (-sco3.2v5.0.) (Lit_LBracket '[') (024) (Lit_RBracket ']') (Lit_Star '*')
                                                                    }
                                                                  ]
                                                                  action: [
                                                                    (command.ShAssignment
                                                                      pairs: [
                                                                        (assign_pair
                                                                          lhs: 
                                                                            (sh_lhs_expr.Name
                                                                              name: add_dir
                                                                            )
                                                                          op: Equal
                                                                          rhs: 
                                                                            {(-L) 
                                                                              ($ VSub_DollarName 
'$dir'
                                                                              )
                                                                            }
                                                                        )
                                                                      ]
                                                                    )
                                                                  ]
                                                                )
                                                                (case_arm
                                                                  pat_list: [
                                                                    {(Lit_Star '*') (-) (Lit_Star '*') 
                                                                      (-sysv4) (Lit_Star '*') (uw2) (Lit_Star '*')
                                                                    }
                                                                  ]
                                                                  action: [
                                                                    (command.ShAssignment
                                                                      pairs: [
                                                                        (assign_pair
                                                                          lhs: 
                                                                            (sh_lhs_expr.Name
                                                                              name: add_dir
                                                                            )
                                                                          op: Equal
                                                                          rhs: 
                                                                            {(-L) 
                                                                              ($ VSub_DollarName 
'$dir'
                                                                              )
                                                                            }
                                                                        )
                                                                      ]
                                                                    )
                                                                  ]
                                                                )
                                                                (case_arm
                                                                  pat_list: [
                                                                    {(Lit_Star '*') (-) (Lit_Star '*') 
                                                                      (-sysv5OpenUNIX) (Lit_Star '*')
                                                                    }
                                                                    {(Lit_Star '*') (-) (Lit_Star '*') 
                                                                      (-sysv5UnixWare7.) (Lit_LBracket '[') (01) (Lit_RBracket ']') (.) (Lit_LBracket '[') (10) (Lit_RBracket ']') (Lit_Star '*')
                                                                    }
                                                                    {(Lit_Star '*') (-) (Lit_Star '*') 
                                                                      (-unixware7) (Lit_Star '*')
                                                                    }
                                                                  ]
                                                                  action: [
                                                                    (command.ShAssignment
                                                                      pairs: [
                                                                        (assign_pair
                                                                          lhs: 
                                                                            (sh_lhs_expr.Name
                                                                              name: add_dir
                                                                            )
                                                                          op: Equal
                                                                          rhs: 
                                                                            {(-L) 
                                                                              ($ VSub_DollarName 
'$dir'
                                                                              )
                                                                            }
                                                                        )
                                                                      ]
                                                                    )
                                                                  ]
                                                                )
                                                                (case_arm
                                                                  pat_list: [
                                                                    {(Lit_Star '*') (-) (Lit_Star '*') 
                                                                      (-darwin) (Lit_Star '*')
                                                                    }
                                                                  ]
                                                                  action: [
                                                                    (command.If
                                                                      arms: [
                                                                        (if_arm
                                                                          cond: [
                                                                            (command.Sentence
                                                                              child: 
                                                                                (command.Pipeline
                                                                                  children: [
                                                                                    (command.Simple
                                                                                      words: [
                                                                                        {
                                                                                          (
/usr/bin/file
                                                                                          )
                                                                                        }
                                                                                        {(-L)}
                                                                                        {
                                                                                          ($ 
VSub_DollarName '$add'
                                                                                          )
                                                                                        }
                                                                                      ]
                                                                                      redirects: [
                                                                                        (redir.Redir
                                                                                          op: 
                                                                                            <
Redir_Great '2>'
                                                                                            >
                                                                                          fd: 2
                                                                                          arg_word: 
                                                                                            {
                                                                                              (
/dev/null
                                                                                              )
                                                                                            }
                                                                                        )
                                                                                      ]
                                                                                    )
                                                                                    (command.Simple
                                                                                      words: [
                                                                                        {
                                                                                          ($ 
VSub_DollarName '$GREP'
                                                                                          )
                                                                                        }
                                                                                        {
                                                                                          (DQ 
                                                                                            (
': [^:]* bundle'
                                                                                            )
                                                                                          )
                                                                                        }
                                                                                      ]
                                                                                      redirects: [
                                                                                        (redir.Redir
                                                                                          op: 
                                                                                            <
Redir_Great '>'
                                                                                            >
                                                                                          fd: 
16777215
                                                                                          arg_word: 
                                                                                            {
                                                                                              (
/dev/null
                                                                                              )
                                                                                            }
                                                                                        )
                                                                                      ]
                                                                                    )
                                                                                  ]
                                                                                  negated: F
                                                                                )
                                                                              terminator: 
                                                                                <Op_Semi ';'>
                                                                            )
                                                                          ]
                                                                          action: [
                                                                            (command.If
                                                                              arms: [
                                                                                (if_arm
                                                                                  cond: [
                                                                                    (command.Sentence
                                                                                      child: 
                                                                                        (C {(test)} 
                                                                                          {
                                                                                            (DQ (X) 
                                                                                              ($ 
VSub_DollarName '$dlopenmodule'
                                                                                              )
                                                                                            )
                                                                                          } {(KW_Bang '!') (Lit_Equals '=')} {(DQ (X) ($ VSub_DollarName '$lib'))}
                                                                                        )
                                                                                      terminator: 
                                                                                        <Op_Semi ';'>
                                                                                    )
                                                                                  ]
                                                                                  action: [
                                                                                    (C 
                                                                                      {
                                                                                        ($ 
VSub_DollarName '$ECHO'
                                                                                        )
                                                                                      } {(DQ ('*** Warning: lib ') ($ VSub_DollarName '$linklib') (' is a module, not a shared library'))}
                                                                                    )
                                                                                    (command.If
                                                                                      arms: [
                                                                                        (if_arm
                                                                                          cond: [
                                                                                            (command.Sentence
                                                                                              child: 
                                                                                                (C 
                                                                                                  {
                                                                                                    (
test
                                                                                                    )
                                                                                                  } {(-z)} {(DQ ($ VSub_DollarName '$old_library'))}
                                                                                                )
                                                                                              terminator: 
                                                                                                <
Op_Semi ';'
                                                                                                >
                                                                                            )
                                                                                          ]
                                                                                          action: [
                                                                                            (C 
                                                                                              {
                                                                                                (
echo
                                                                                                )
                                                                                              }
                                                                                            )
                                                                                            (C 
                                                                                              {
                                                                                                (
echo
                                                                                                )
                                                                                              } {(DQ ("*** And there doesn't seem to be a static archive available"))}
                                                                                            )
                                                                                            (C 
                                                                                              {
                                                                                                (
echo
                                                                                                )
                                                                                              } {(DQ ('*** The link will probably fail, sorry'))}
                                                                                            )
                                                                                          ]
                                                                                        )
                                                                                      ]
                                                                                      else_action: [
                                                                                        (command.ShAssignment
                                                                                          pairs: [
                                                                                            (assign_pair
                                                                                              lhs: 
                                                                                                (sh_lhs_expr.Name
                                                                                                  name: 
add
                                                                                                )
                                                                                              op: 
Equal
                                                                                              rhs: 
                                                                                                {
                                                                                                  ($ 
VSub_DollarName '$dir'
                                                                                                  ) (/) ($ VSub_DollarName '$old_library')
                                                                                                }
                                                                                            )
                                                                                          ]
                                                                                        )
                                                                                      ]
                                                                                    )
                                                                                  ]
                                                                                )
                                                                                (if_arm
                                                                                  cond: [
                                                                                    (command.Sentence
                                                                                      child: 
                                                                                        (C {(test)} 
                                                                                          {(-n)} {(DQ ($ VSub_DollarName '$old_library'))}
                                                                                        )
                                                                                      terminator: 
                                                                                        <Op_Semi ';'>
                                                                                    )
                                                                                  ]
                                                                                  action: [
                                                                                    (command.ShAssignment
                                                                                      pairs: [
                                                                                        (assign_pair
                                                                                          lhs: 
                                                                                            (sh_lhs_expr.Name
                                                                                              name: 
add
                                                                                            )
                                                                                          op: Equal
                                                                                          rhs: 
                                                                                            {
                                                                                              ($ 
VSub_DollarName '$dir'
                                                                                              ) (/) ($ VSub_DollarName '$old_library')
                                                                                            }
                                                                                        )
                                                                                      ]
                                                                                    )
                                                                                  ]
                                                                                )
                                                                              ]
                                                                            )
                                                                          ]
                                                                        )
                                                                      ]
                                                                    )
                                                                  ]
                                                                )
                                                              ]
                                                            )
                                                          ]
                                                        )
                                                        (if_arm
                                                          cond: [
                                                            (command.Sentence
                                                              child: 
                                                                (C {(test)} {(no)} {(Lit_Equals '=')} 
                                                                  {
                                                                    (DQ 
                                                                      ($ VSub_DollarName 
'$hardcode_minus_L'
                                                                      )
                                                                    )
                                                                  }
                                                                )
                                                              terminator: <Op_Semi ';'>
                                                            )
                                                          ]
                                                          action: [
                                                            (command.Case
                                                              to_match: {($ VSub_DollarName '$host')}
                                                              arms: [
                                                                (case_arm
                                                                  pat_list: [
                                                                    {(Lit_Star '*') (-) (Lit_Star '*') 
                                                                      (-sunos) (Lit_Star '*')
                                                                    }
                                                                  ]
                                                                  action: [
                                                                    (command.ShAssignment
                                                                      pairs: [
                                                                        (assign_pair
                                                                          lhs: 
                                                                            (sh_lhs_expr.Name
                                                                              name: add_shlibpath
                                                                            )
                                                                          op: Equal
                                                                          rhs: 
                                                                            {
                                                                              ($ VSub_DollarName 
'$dir'
                                                                              )
                                                                            }
                                                                        )
                                                                      ]
                                                                    )
                                                                  ]
                                                                )
                                                              ]
                                                            )
                                                            (command.ShAssignment
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: 
                                                                    (sh_lhs_expr.Name
                                                                      name: add_dir
                                                                    )
                                                                  op: Equal
                                                                  rhs: 
                                                                    {(-L) ($ VSub_DollarName '$dir')}
                                                                )
                                                              ]
                                                            )
                                                            (command.ShAssignment
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: (sh_lhs_expr.Name name:add)
                                                                  op: Equal
                                                                  rhs: 
                                                                    {(-l) ($ VSub_DollarName '$name')}
                                                                )
                                                              ]
                                                            )
                                                          ]
                                                        )
                                                        (if_arm
                                                          cond: [
                                                            (command.Sentence
                                                              child: 
                                                                (C {(test)} {(no)} {(Lit_Equals '=')} 
                                                                  {
                                                                    (DQ 
                                                                      ($ VSub_DollarName 
'$hardcode_shlibpath_var'
                                                                      )
                                                                    )
                                                                  }
                                                                )
                                                              terminator: <Op_Semi ';'>
                                                            )
                                                          ]
                                                          action: [
                                                            (command.ShAssignment
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: 
                                                                    (sh_lhs_expr.Name
                                                                      name: add_shlibpath
                                                                    )
                                                                  op: Equal
                                                                  rhs: {($ VSub_DollarName '$dir')}
                                                                )
                                                              ]
                                                            )
                                                            (command.ShAssignment
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: (sh_lhs_expr.Name name:add)
                                                                  op: Equal
                                                                  rhs: 
                                                                    {(-l) ($ VSub_DollarName '$name')}
                                                                )
                                                              ]
                                                            )
                                                          ]
                                                        )
                                                      ]
                                                      else_action: [
                                                        (command.ShAssignment
                                                          pairs: [
                                                            (assign_pair
                                                              lhs: (sh_lhs_expr.Name name:lib_linked)
                                                              op: Equal
                                                              rhs: {(no)}
                                                            )
                                                          ]
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                )
                                                (case_arm
                                                  pat_list: [{(relink)}]
                                                  action: [
                                                    (command.If
                                                      arms: [
                                                        (if_arm
                                                          cond: [
                                                            (command.Sentence
                                                              child: 
                                                                (command.AndOr
                                                                  ops: [Op_DAmp]
                                                                  children: [
                                                                    (C {(test)} {(yes)} 
                                                                      {(Lit_Equals '=')} {(DQ ($ VSub_DollarName '$hardcode_direct'))}
                                                                    )
                                                                    (C {(test)} {(no)} 
                                                                      {(Lit_Equals '=')} {(DQ ($ VSub_DollarName '$hardcode_direct_absolute'))}
                                                                    )
                                                                  ]
                                                                )
                                                              terminator: <Op_Semi ';'>
                                                            )
                                                          ]
                                                          action: [
                                                            (command.ShAssignment
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: (sh_lhs_expr.Name name:add)
                                                                  op: Equal
                                                                  rhs: 
                                                                    {($ VSub_DollarName '$dir') (/) 
                                                                      ($ VSub_DollarName '$linklib')
                                                                    }
                                                                )
                                                              ]
                                                            )
                                                          ]
                                                        )
                                                        (if_arm
                                                          cond: [
                                                            (command.Sentence
                                                              child: 
                                                                (C {(test)} {(yes)} {(Lit_Equals '=')} 
                                                                  {
                                                                    (DQ 
                                                                      ($ VSub_DollarName 
'$hardcode_minus_L'
                                                                      )
                                                                    )
                                                                  }
                                                                )
                                                              terminator: <Op_Semi ';'>
                                                            )
                                                          ]
                                                          action: [
                                                            (command.ShAssignment
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: 
                                                                    (sh_lhs_expr.Name
                                                                      name: add_dir
                                                                    )
                                                                  op: Equal
                                                                  rhs: 
                                                                    {(-L) 
                                                                      ($ VSub_DollarName '$absdir')
                                                                    }
                                                                )
                                                              ]
                                                            )
                                                            (command.If
                                                              arms: [
                                                                (if_arm
                                                                  cond: [
                                                                    (command.Sentence
                                                                      child: 
                                                                        (C {(test)} {(-n)} 
                                                                          {
                                                                            (DQ 
                                                                              ($ VSub_DollarName 
'$inst_prefix_dir'
                                                                              )
                                                                            )
                                                                          }
                                                                        )
                                                                      terminator: <Op_Semi ';'>
                                                                    )
                                                                  ]
                                                                  action: [
                                                                    (command.Case
                                                                      to_match: 
                                                                        {
                                                                          ($ VSub_DollarName 
'$libdir'
                                                                          )
                                                                        }
                                                                      arms: [
                                                                        (case_arm
                                                                          pat_list: [
                                                                            {(Lit_LBracket '[') 
                                                                              (word_part.EscapedLiteral
                                                                                token: 
                                                                                  <Lit_EscapedChar 
'\\\\'
                                                                                  >
                                                                              ) (/) (Lit_RBracket ']') (Lit_Star '*')
                                                                            }
                                                                          ]
                                                                          action: [
                                                                            (C {(func_append)} 
                                                                              {(add_dir)} {(DQ (' -L') ($ VSub_DollarName '$inst_prefix_dir') ($ VSub_DollarName '$libdir'))}
                                                                            )
                                                                          ]
                                                                        )
                                                                      ]
                                                                    )
                                                                  ]
                                                                )
                                                              ]
                                                            )
                                                            (command.ShAssignment
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: (sh_lhs_expr.Name name:add)
                                                                  op: Equal
                                                                  rhs: 
                                                                    {(-l) ($ VSub_DollarName '$name')}
                                                                )
                                                              ]
                                                            )
                                                          ]
                                                        )
                                                        (if_arm
                                                          cond: [
                                                            (command.Sentence
                                                              child: 
                                                                (C {(test)} {(yes)} {(Lit_Equals '=')} 
                                                                  {
                                                                    (DQ 
                                                                      ($ VSub_DollarName 
'$hardcode_shlibpath_var'
                                                                      )
                                                                    )
                                                                  }
                                                                )
                                                              terminator: <Op_Semi ';'>
                                                            )
                                                          ]
                                                          action: [
                                                            (command.ShAssignment
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: 
                                                                    (sh_lhs_expr.Name
                                                                      name: add_shlibpath
                                                                    )
                                                                  op: Equal
                                                                  rhs: {($ VSub_DollarName '$dir')}
                                                                )
                                                              ]
                                                            )
                                                            (command.ShAssignment
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: (sh_lhs_expr.Name name:add)
                                                                  op: Equal
                                                                  rhs: 
                                                                    {(-l) ($ VSub_DollarName '$name')}
                                                                )
                                                              ]
                                                            )
                                                          ]
                                                        )
                                                      ]
                                                      else_action: [
                                                        (command.ShAssignment
                                                          pairs: [
                                                            (assign_pair
                                                              lhs: (sh_lhs_expr.Name name:lib_linked)
                                                              op: Equal
                                                              rhs: {(no)}
                                                            )
                                                          ]
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                )
                                                (case_arm
                                                  pat_list: [{(Lit_Star '*')}]
                                                  action: [
                                                    (command.ShAssignment
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (sh_lhs_expr.Name name:lib_linked)
                                                          op: Equal
                                                          rhs: {(no)}
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                )
                                              ]
                                            )
                                            (command.If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (command.Sentence
                                                      child: 
                                                        (C {(test)} {(yes)} 
                                                          {(KW_Bang '!') (Lit_Equals '=')} {(DQ ($ VSub_DollarName '$lib_linked'))}
                                                        )
                                                      terminator: <Op_Semi ';'>
                                                    )
                                                  ]
                                                  action: [
                                                    (C {(func_fatal_configuration)} 
                                                      {(DQ ('unsupported hardcode properties'))}
                                                    )
                                                  ]
                                                )
                                              ]
                                            )
                                            (command.If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (command.Sentence
                                                      child: 
                                                        (C {(test)} {(-n)} 
                                                          {(DQ ($ VSub_DollarName '$add_shlibpath'))}
                                                        )
                                                      terminator: <Op_Semi ';'>
                                                    )
                                                  ]
                                                  action: [
                                                    (command.Case
                                                      to_match: 
                                                        {(Lit_Other ':') 
                                                          ($ VSub_DollarName '$compile_shlibpath') (Lit_Other ':')
                                                        }
                                                      arms: [
                                                        (case_arm
                                                          pat_list: [
                                                            {(Lit_Star '*') 
                                                              (DQ (':') 
                                                                ($ VSub_DollarName '$add_shlibpath') (':')
                                                              ) (Lit_Star '*')
                                                            }
                                                          ]
                                                        )
                                                        (case_arm
                                                          pat_list: [{(Lit_Star '*')}]
                                                          action: [
                                                            (C {(func_append)} {(compile_shlibpath)} 
                                                              {
                                                                (DQ 
                                                                  ($ VSub_DollarName '$add_shlibpath') (':')
                                                                )
                                                              }
                                                            )
                                                          ]
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                )
                                              ]
                                            )
                                            (command.If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (command.Sentence
                                                      child: 
                                                        (C {(test)} {(prog)} {(Lit_Equals '=')} 
                                                          {(DQ ($ VSub_DollarName '$linkmode'))}
                                                        )
                                                      terminator: <Op_Semi ';'>
                                                    )
                                                  ]
                                                  action: [
                                                    (command.AndOr
                                                      ops: [Op_DAmp]
                                                      children: [
                                                        (C {(test)} {(-n)} 
                                                          {(DQ ($ VSub_DollarName '$add_dir'))}
                                                        )
                                                        (command.ShAssignment
                                                          pairs: [
                                                            (assign_pair
                                                              lhs: 
                                                                (sh_lhs_expr.Name
                                                                  name: compile_deplibs
                                                                )
                                                              op: Equal
                                                              rhs: 
                                                                {
                                                                  (DQ ($ VSub_DollarName '$add_dir') 
                                                                    (' ') ($ VSub_DollarName '$compile_deplibs')
                                                                  )
                                                                }
                                                            )
                                                          ]
                                                        )
                                                      ]
                                                    )
                                                    (command.AndOr
                                                      ops: [Op_DAmp]
                                                      children: [
                                                        (C {(test)} {(-n)} 
                                                          {(DQ ($ VSub_DollarName '$add'))}
                                                        )
                                                        (command.ShAssignment
                                                          pairs: [
                                                            (assign_pair
                                                              lhs: 
                                                                (sh_lhs_expr.Name
                                                                  name: compile_deplibs
                                                                )
                                                              op: Equal
                                                              rhs: 
                                                                {
                                                                  (DQ ($ VSub_DollarName '$add') (' ') 
                                                                    ($ VSub_DollarName 
'$compile_deplibs'
                                                                    )
                                                                  )
                                                                }
                                                            )
                                                          ]
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                )
                                              ]
                                              else_action: [
                                                (command.AndOr
                                                  ops: [Op_DAmp]
                                                  children: [
                                                    (C {(test)} {(-n)} 
                                                      {(DQ ($ VSub_DollarName '$add_dir'))}
                                                    )
                                                    (command.ShAssignment
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (sh_lhs_expr.Name name:deplibs)
                                                          op: Equal
                                                          rhs: 
                                                            {
                                                              (DQ ($ VSub_DollarName '$add_dir') (' ') 
                                                                ($ VSub_DollarName '$deplibs')
                                                              )
                                                            }
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                )
                                                (command.AndOr
                                                  ops: [Op_DAmp]
                                                  children: [
                                                    (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$add'))})
                                                    (command.ShAssignment
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (sh_lhs_expr.Name name:deplibs)
                                                          op: Equal
                                                          rhs: 
                                                            {
                                                              (DQ ($ VSub_DollarName '$add') (' ') 
                                                                ($ VSub_DollarName '$deplibs')
                                                              )
                                                            }
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                )
                                                (command.If
                                                  arms: [
                                                    (if_arm
                                                      cond: [
                                                        (command.Sentence
                                                          child: 
                                                            (command.AndOr
                                                              ops: [Op_DAmp Op_DAmp]
                                                              children: [
                                                                (C {(test)} {(yes)} 
                                                                  {(KW_Bang '!') (Lit_Equals '=')} {(DQ ($ VSub_DollarName '$hardcode_direct'))}
                                                                )
                                                                (C {(test)} {(yes)} 
                                                                  {(KW_Bang '!') (Lit_Equals '=')} {(DQ ($ VSub_DollarName '$hardcode_minus_L'))}
                                                                )
                                                                (C {(test)} {(yes)} {(Lit_Equals '=')} 
                                                                  {
                                                                    (DQ 
                                                                      ($ VSub_DollarName 
'$hardcode_shlibpath_var'
                                                                      )
                                                                    )
                                                                  }
                                                                )
                                                              ]
                                                            )
                                                          terminator: <Op_Semi ';'>
                                                        )
                                                      ]
                                                      action: [
                                                        (command.Case
                                                          to_match: 
                                                            {(Lit_Other ':') 
                                                              ($ VSub_DollarName 
'$finalize_shlibpath'
                                                              ) (Lit_Other ':')
                                                            }
                                                          arms: [
                                                            (case_arm
                                                              pat_list: [
                                                                {(Lit_Star '*') 
                                                                  (DQ (':') 
                                                                    ($ VSub_DollarName '$libdir') (':')
                                                                  ) (Lit_Star '*')
                                                                }
                                                              ]
                                                            )
                                                            (case_arm
                                                              pat_list: [{(Lit_Star '*')}]
                                                              action: [
                                                                (C {(func_append)} 
                                                                  {(finalize_shlibpath)} {(DQ ($ VSub_DollarName '$libdir') (':'))}
                                                                )
                                                              ]
                                                            )
                                                          ]
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (command.Sentence
                                              child: 
                                                (command.AndOr
                                                  ops: [Op_DPipe]
                                                  children: [
                                                    (C {(test)} {(prog)} {(Lit_Equals '=')} 
                                                      {(DQ ($ VSub_DollarName '$linkmode'))}
                                                    )
                                                    (C {(test)} {(relink)} {(Lit_Equals '=')} 
                                                      {(DQ ($ VSub_DollarName '$opt_mode'))}
                                                    )
                                                  ]
                                                )
                                              terminator: <Op_Semi ';'>
                                            )
                                          ]
                                          action: [
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:add_shlibpath)
                                                  op: Equal
                                                  rhs: (word.Empty)
                                                )
                                              ]
                                            )
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:add_dir)
                                                  op: Equal
                                                  rhs: (word.Empty)
                                                )
                                              ]
                                            )
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:add)
                                                  op: Equal
                                                  rhs: (word.Empty)
                                                )
                                              ]
                                            )
                                            (command.If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (command.Sentence
                                                      child: 
                                                        (command.AndOr
                                                          ops: [Op_DAmp]
                                                          children: [
                                                            (C {(test)} {(yes)} {(Lit_Equals '=')} 
                                                              {
                                                                (DQ 
                                                                  ($ VSub_DollarName 
'$hardcode_direct'
                                                                  )
                                                                )
                                                              }
                                                            )
                                                            (C {(test)} {(no)} {(Lit_Equals '=')} 
                                                              {
                                                                (DQ 
                                                                  ($ VSub_DollarName 
'$hardcode_direct_absolute'
                                                                  )
                                                                )
                                                              }
                                                            )
                                                          ]
                                                        )
                                                      terminator: <Op_Semi ';'>
                                                    )
                                                  ]
                                                  action: [
                                                    (command.ShAssignment
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (sh_lhs_expr.Name name:add)
                                                          op: Equal
                                                          rhs: 
                                                            {($ VSub_DollarName '$libdir') (/) 
                                                              ($ VSub_DollarName '$linklib')
                                                            }
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                )
                                                (if_arm
                                                  cond: [
                                                    (command.Sentence
                                                      child: 
                                                        (C {(test)} {(yes)} {(Lit_Equals '=')} 
                                                          {
                                                            (DQ 
                                                              ($ VSub_DollarName '$hardcode_minus_L')
                                                            )
                                                          }
                                                        )
                                                      terminator: <Op_Semi ';'>
                                                    )
                                                  ]
                                                  action: [
                                                    (command.ShAssignment
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (sh_lhs_expr.Name name:add_dir)
                                                          op: Equal
                                                          rhs: {(-L) ($ VSub_DollarName '$libdir')}
                                                        )
                                                      ]
                                                    )
                                                    (command.ShAssignment
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (sh_lhs_expr.Name name:add)
                                                          op: Equal
                                                          rhs: {(-l) ($ VSub_DollarName '$name')}
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                )
                                                (if_arm
                                                  cond: [
                                                    (command.Sentence
                                                      child: 
                                                        (C {(test)} {(yes)} {(Lit_Equals '=')} 
                                                          {
                                                            (DQ 
                                                              ($ VSub_DollarName 
'$hardcode_shlibpath_var'
                                                              )
                                                            )
                                                          }
                                                        )
                                                      terminator: <Op_Semi ';'>
                                                    )
                                                  ]
                                                  action: [
                                                    (command.Case
                                                      to_match: 
                                                        {(Lit_Other ':') 
                                                          ($ VSub_DollarName '$finalize_shlibpath') (Lit_Other ':')
                                                        }
                                                      arms: [
                                                        (case_arm
                                                          pat_list: [
                                                            {(Lit_Star '*') 
                                                              (DQ (':') ($ VSub_DollarName '$libdir') 
                                                                (':')
                                                              ) (Lit_Star '*')
                                                            }
                                                          ]
                                                        )
                                                        (case_arm
                                                          pat_list: [{(Lit_Star '*')}]
                                                          action: [
                                                            (C {(func_append)} {(finalize_shlibpath)} 
                                                              {
                                                                (DQ ($ VSub_DollarName '$libdir') 
                                                                  (':')
                                                                )
                                                              }
                                                            )
                                                          ]
                                                        )
                                                      ]
                                                    )
                                                    (command.ShAssignment
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (sh_lhs_expr.Name name:add)
                                                          op: Equal
                                                          rhs: {(-l) ($ VSub_DollarName '$name')}
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                )
                                                (if_arm
                                                  cond: [
                                                    (command.Sentence
                                                      child: 
                                                        (C {(test)} {(yes)} {(Lit_Equals '=')} 
                                                          {
                                                            (DQ 
                                                              ($ VSub_DollarName 
'$hardcode_automatic'
                                                              )
                                                            )
                                                          }
                                                        )
                                                      terminator: <Op_Semi ';'>
                                                    )
                                                  ]
                                                  action: [
                                                    (command.If
                                                      arms: [
                                                        (if_arm
                                                          cond: [
                                                            (command.Sentence
                                                              child: 
                                                                (command.AndOr
                                                                  ops: [Op_DAmp]
                                                                  children: [
                                                                    (C {(test)} {(-n)} 
                                                                      {
                                                                        (DQ 
                                                                          ($ VSub_DollarName 
'$inst_prefix_dir'
                                                                          )
                                                                        )
                                                                      }
                                                                    )
                                                                    (C {(test)} {(-f)} 
                                                                      {
                                                                        (DQ 
                                                                          ($ VSub_DollarName 
'$inst_prefix_dir'
                                                                          ) ($ VSub_DollarName '$libdir') (/) ($ VSub_DollarName '$linklib')
                                                                        )
                                                                      }
                                                                    )
                                                                  ]
                                                                )
                                                              terminator: <Op_Semi ';'>
                                                            )
                                                          ]
                                                          action: [
                                                            (command.ShAssignment
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: (sh_lhs_expr.Name name:add)
                                                                  op: Equal
                                                                  rhs: 
                                                                    {
                                                                      ($ VSub_DollarName 
'$inst_prefix_dir'
                                                                      ) ($ VSub_DollarName '$libdir') (/) ($ VSub_DollarName '$linklib')
                                                                    }
                                                                )
                                                              ]
                                                            )
                                                          ]
                                                        )
                                                      ]
                                                      else_action: [
                                                        (command.ShAssignment
                                                          pairs: [
                                                            (assign_pair
                                                              lhs: (sh_lhs_expr.Name name:add)
                                                              op: Equal
                                                              rhs: 
                                                                {($ VSub_DollarName '$libdir') (/) 
                                                                  ($ VSub_DollarName '$linklib')
                                                                }
                                                            )
                                                          ]
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                )
                                              ]
                                              else_action: [
                                                (command.ShAssignment
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (sh_lhs_expr.Name name:add_dir)
                                                      op: Equal
                                                      rhs: {(-L) ($ VSub_DollarName '$libdir')}
                                                    )
                                                  ]
                                                )
                                                (command.If
                                                  arms: [
                                                    (if_arm
                                                      cond: [
                                                        (command.Sentence
                                                          child: 
                                                            (C {(test)} {(-n)} 
                                                              {
                                                                (DQ 
                                                                  ($ VSub_DollarName 
'$inst_prefix_dir'
                                                                  )
                                                                )
                                                              }
                                                            )
                                                          terminator: <Op_Semi ';'>
                                                        )
                                                      ]
                                                      action: [
                                                        (command.Case
                                                          to_match: {($ VSub_DollarName '$libdir')}
                                                          arms: [
                                                            (case_arm
                                                              pat_list: [
                                                                {(Lit_LBracket '[') 
                                                                  (word_part.EscapedLiteral
                                                                    token: <Lit_EscapedChar '\\\\'>
                                                                  ) (/) (Lit_RBracket ']') (Lit_Star '*')
                                                                }
                                                              ]
                                                              action: [
                                                                (C {(func_append)} {(add_dir)} 
                                                                  {
                                                                    (DQ (' -L') 
                                                                      ($ VSub_DollarName 
'$inst_prefix_dir'
                                                                      ) ($ VSub_DollarName '$libdir')
                                                                    )
                                                                  }
                                                                )
                                                              ]
                                                            )
                                                          ]
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                )
                                                (command.ShAssignment
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (sh_lhs_expr.Name name:add)
                                                      op: Equal
                                                      rhs: {(-l) ($ VSub_DollarName '$name')}
                                                    )
                                                  ]
                                                )
                                              ]
                                            )
                                            (command.If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (command.Sentence
                                                      child: 
                                                        (C {(test)} {(prog)} {(Lit_Equals '=')} 
                                                          {(DQ ($ VSub_DollarName '$linkmode'))}
                                                        )
                                                      terminator: <Op_Semi ';'>
                                                    )
                                                  ]
                                                  action: [
                                                    (command.AndOr
                                                      ops: [Op_DAmp]
                                                      children: [
                                                        (C {(test)} {(-n)} 
                                                          {(DQ ($ VSub_DollarName '$add_dir'))}
                                                        )
                                                        (command.ShAssignment
                                                          pairs: [
                                                            (assign_pair
                                                              lhs: 
                                                                (sh_lhs_expr.Name
                                                                  name: finalize_deplibs
                                                                )
                                                              op: Equal
                                                              rhs: 
                                                                {
                                                                  (DQ ($ VSub_DollarName '$add_dir') 
                                                                    (' ') ($ VSub_DollarName '$finalize_deplibs')
                                                                  )
                                                                }
                                                            )
                                                          ]
                                                        )
                                                      ]
                                                    )
                                                    (command.AndOr
                                                      ops: [Op_DAmp]
                                                      children: [
                                                        (C {(test)} {(-n)} 
                                                          {(DQ ($ VSub_DollarName '$add'))}
                                                        )
                                                        (command.ShAssignment
                                                          pairs: [
                                                            (assign_pair
                                                              lhs: 
                                                                (sh_lhs_expr.Name
                                                                  name: finalize_deplibs
                                                                )
                                                              op: Equal
                                                              rhs: 
                                                                {
                                                                  (DQ ($ VSub_DollarName '$add') (' ') 
                                                                    ($ VSub_DollarName 
'$finalize_deplibs'
                                                                    )
                                                                  )
                                                                }
                                                            )
                                                          ]
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                )
                                              ]
                                              else_action: [
                                                (command.AndOr
                                                  ops: [Op_DAmp]
                                                  children: [
                                                    (C {(test)} {(-n)} 
                                                      {(DQ ($ VSub_DollarName '$add_dir'))}
                                                    )
                                                    (command.ShAssignment
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (sh_lhs_expr.Name name:deplibs)
                                                          op: Equal
                                                          rhs: 
                                                            {
                                                              (DQ ($ VSub_DollarName '$add_dir') (' ') 
                                                                ($ VSub_DollarName '$deplibs')
                                                              )
                                                            }
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                )
                                                (command.AndOr
                                                  ops: [Op_DAmp]
                                                  children: [
                                                    (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$add'))})
                                                    (command.ShAssignment
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (sh_lhs_expr.Name name:deplibs)
                                                          op: Equal
                                                          rhs: 
                                                            {
                                                              (DQ ($ VSub_DollarName '$add') (' ') 
                                                                ($ VSub_DollarName '$deplibs')
                                                              )
                                                            }
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                  ]
                                )
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (C {(test)} {(prog)} {(Lit_Equals '=')} 
                                          {(DQ ($ VSub_DollarName '$linkmode'))}
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (command.Sentence
                                              child: 
                                                (C {(test)} {(unsupported)} 
                                                  {(KW_Bang '!') (Lit_Equals '=')} {(DQ ($ VSub_DollarName '$hardcode_direct'))}
                                                )
                                              terminator: <Op_Semi ';'>
                                            )
                                          ]
                                          action: [
                                            (command.AndOr
                                              ops: [Op_DAmp]
                                              children: [
                                                (C {(test)} {(-n)} 
                                                  {(DQ ($ VSub_DollarName '$old_library'))}
                                                )
                                                (command.ShAssignment
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (sh_lhs_expr.Name name:linklib)
                                                      op: Equal
                                                      rhs: {($ VSub_DollarName '$old_library')}
                                                    )
                                                  ]
                                                )
                                              ]
                                            )
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:compile_deplibs)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ ($ VSub_DollarName '$dir') (/) 
                                                        ($ VSub_DollarName '$linklib') (' ') ($ VSub_DollarName '$compile_deplibs')
                                                      )
                                                    }
                                                )
                                              ]
                                            )
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:finalize_deplibs)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ ($ VSub_DollarName '$dir') (/) 
                                                        ($ VSub_DollarName '$linklib') (' ') ($ VSub_DollarName '$finalize_deplibs')
                                                      )
                                                    }
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                      ]
                                      else_action: [
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:compile_deplibs)
                                              op: Equal
                                              rhs: 
                                                {
                                                  (DQ (-l) ($ VSub_DollarName '$name') (' -L') 
                                                    ($ VSub_DollarName '$dir') (' ') ($ VSub_DollarName '$compile_deplibs')
                                                  )
                                                }
                                            )
                                          ]
                                        )
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:finalize_deplibs)
                                              op: Equal
                                              rhs: 
                                                {
                                                  (DQ (-l) ($ VSub_DollarName '$name') (' -L') 
                                                    ($ VSub_DollarName '$dir') (' ') ($ VSub_DollarName '$finalize_deplibs')
                                                  )
                                                }
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                  ]
                                )
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (C {(test)} {(yes)} {(Lit_Equals '=')} 
                                          {(DQ ($ VSub_DollarName '$build_libtool_libs'))}
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (command.Sentence
                                              child: 
                                                (C {(test)} {(pass_all)} 
                                                  {(KW_Bang '!') (Lit_Equals '=')} {(DQ ($ VSub_DollarName '$deplibs_check_method'))}
                                                )
                                              terminator: <Op_Semi ';'>
                                            )
                                          ]
                                          action: [
                                            (C {(echo)})
                                            (C {($ VSub_DollarName '$ECHO')} 
                                              {
                                                (DQ 
                                                  (
'*** Warning: This system cannot link to static lib archive '
                                                  ) ($ VSub_DollarName '$lib') (.)
                                                )
                                              }
                                            )
                                            (C {(echo)} 
                                              {
                                                (DQ 
                                                  (
'*** I have the capability to make that library automatically link in when'
                                                  )
                                                )
                                              }
                                            )
                                            (C {(echo)} 
                                              {
                                                (DQ 
                                                  (
'*** you link to this library.  But I can only do this if you have a'
                                                  )
                                                )
                                              }
                                            )
                                            (C {(echo)} 
                                              {
                                                (DQ 
                                                  (
'*** shared version of the library, which you do not appear to have.'
                                                  )
                                                )
                                              }
                                            )
                                            (command.If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (command.Sentence
                                                      child: 
                                                        (C {(test)} {(yes)} {(Lit_Equals '=')} 
                                                          {(DQ ($ VSub_DollarName '$module'))}
                                                        )
                                                      terminator: <Op_Semi ';'>
                                                    )
                                                  ]
                                                  action: [
                                                    (C {(echo)} 
                                                      {
                                                        (DQ 
                                                          (
'*** But as you try to build a module library, libtool will still create '
                                                          )
                                                        )
                                                      }
                                                    )
                                                    (C {(echo)} 
                                                      {
                                                        (DQ 
                                                          (
'*** a static module, that should work as long as the dlopening application'
                                                          )
                                                        )
                                                      }
                                                    )
                                                    (C {(echo)} 
                                                      {
                                                        (DQ 
                                                          (
'*** is linked with the -dlopen flag to resolve symbols at runtime.'
                                                          )
                                                        )
                                                      }
                                                    )
                                                    (command.If
                                                      arms: [
                                                        (if_arm
                                                          cond: [
                                                            (command.Sentence
                                                              child: 
                                                                (C {(test)} {(-z)} 
                                                                  {
                                                                    (DQ 
                                                                      ($ VSub_DollarName 
'$global_symbol_pipe'
                                                                      )
                                                                    )
                                                                  }
                                                                )
                                                              terminator: <Op_Semi ';'>
                                                            )
                                                          ]
                                                          action: [
                                                            (C {(echo)})
                                                            (C {(echo)} 
                                                              {
                                                                (DQ 
                                                                  (
'*** However, this would only work if libtool was able to extract symbol'
                                                                  )
                                                                )
                                                              }
                                                            )
                                                            (C {(echo)} 
                                                              {
                                                                (DQ 
                                                                  (
"*** lists from a program, using 'nm' or equivalent, but libtool could"
                                                                  )
                                                                )
                                                              }
                                                            )
                                                            (C {(echo)} 
                                                              {
                                                                (DQ 
                                                                  (
'*** not find such a program.  So, this module is probably useless.'
                                                                  )
                                                                )
                                                              }
                                                            )
                                                            (C {(echo)} 
                                                              {
                                                                (DQ 
                                                                  (
"*** 'nm' from GNU binutils and a full rebuild may help."
                                                                  )
                                                                )
                                                              }
                                                            )
                                                          ]
                                                        )
                                                      ]
                                                    )
                                                    (command.If
                                                      arms: [
                                                        (if_arm
                                                          cond: [
                                                            (command.Sentence
                                                              child: 
                                                                (C {(test)} {(no)} {(Lit_Equals '=')} 
                                                                  {
                                                                    (DQ 
                                                                      ($ VSub_DollarName 
'$build_old_libs'
                                                                      )
                                                                    )
                                                                  }
                                                                )
                                                              terminator: <Op_Semi ';'>
                                                            )
                                                          ]
                                                          action: [
                                                            (command.ShAssignment
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: 
                                                                    (sh_lhs_expr.Name
                                                                      name: build_libtool_libs
                                                                    )
                                                                  op: Equal
                                                                  rhs: {(module)}
                                                                )
                                                              ]
                                                            )
                                                            (command.ShAssignment
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: 
                                                                    (sh_lhs_expr.Name
                                                                      name: build_old_libs
                                                                    )
                                                                  op: Equal
                                                                  rhs: {(yes)}
                                                                )
                                                              ]
                                                            )
                                                          ]
                                                        )
                                                      ]
                                                      else_action: [
                                                        (command.ShAssignment
                                                          pairs: [
                                                            (assign_pair
                                                              lhs: 
                                                                (sh_lhs_expr.Name
                                                                  name: build_libtool_libs
                                                                )
                                                              op: Equal
                                                              rhs: {(no)}
                                                            )
                                                          ]
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                      ]
                                      else_action: [
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:deplibs)
                                              op: Equal
                                              rhs: 
                                                {
                                                  (DQ ($ VSub_DollarName '$dir') (/) 
                                                    ($ VSub_DollarName '$old_library') (' ') ($ VSub_DollarName '$deplibs')
                                                  )
                                                }
                                            )
                                          ]
                                        )
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:link_static)
                                              op: Equal
                                              rhs: {(yes)}
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (C {(test)} {(lib)} {(Lit_Equals '=')} 
                                          {(DQ ($ VSub_DollarName '$linkmode'))}
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (command.Sentence
                                              child: 
                                                (command.AndOr
                                                  ops: [Op_DAmp]
                                                  children: [
                                                    (C {(test)} {(-n)} 
                                                      {(DQ ($ VSub_DollarName '$dependency_libs'))}
                                                    )
                                                    (command.BraceGroup
                                                      children: [
                                                        (command.Sentence
                                                          child: 
                                                            (command.AndOr
                                                              ops: [Op_DPipe Op_DPipe]
                                                              children: [
                                                                (C {(test)} {(yes)} 
                                                                  {(KW_Bang '!') (Lit_Equals '=')} {(DQ ($ VSub_DollarName '$hardcode_into_libs'))}
                                                                )
                                                                (C {(test)} {(yes)} {(Lit_Equals '=')} 
                                                                  {
                                                                    (DQ 
                                                                      ($ VSub_DollarName 
'$build_old_libs'
                                                                      )
                                                                    )
                                                                  }
                                                                )
                                                                (C {(test)} {(yes)} {(Lit_Equals '=')} 
                                                                  {
                                                                    (DQ 
                                                                      ($ VSub_DollarName 
'$link_static'
                                                                      )
                                                                    )
                                                                  }
                                                                )
                                                              ]
                                                            )
                                                          terminator: <Op_Semi ';'>
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                )
                                              terminator: <Op_Semi ';'>
                                            )
                                          ]
                                          action: [
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:temp_deplibs)
                                                  op: Equal
                                                  rhs: (word.Empty)
                                                )
                                              ]
                                            )
                                            (command.ForEach
                                              iter_name: libdir
                                              iter_words: [{($ VSub_DollarName '$dependency_libs')}]
                                              do_arg_iter: F
                                              body: 
                                                (command.DoGroup
                                                  children: [
                                                    (command.Case
                                                      to_match: {($ VSub_DollarName '$libdir')}
                                                      arms: [
                                                        (case_arm
                                                          pat_list: [{(-R) (Lit_Star '*')}]
                                                          action: [
                                                            (C {(func_stripname)} {(SQ <-R>)} {(SQ )} 
                                                              {(DQ ($ VSub_DollarName '$libdir'))}
                                                            )
                                                            (command.ShAssignment
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: 
                                                                    (sh_lhs_expr.Name
                                                                      name: temp_xrpath
                                                                    )
                                                                  op: Equal
                                                                  rhs: 
                                                                    {
                                                                      ($ VSub_DollarName 
'$func_stripname_result'
                                                                      )
                                                                    }
                                                                )
                                                              ]
                                                            )
                                                            (command.Case
                                                              to_match: 
                                                                {
                                                                  (DQ (' ') 
                                                                    ($ VSub_DollarName '$xrpath') (' ')
                                                                  )
                                                                }
                                                              arms: [
                                                                (case_arm
                                                                  pat_list: [
                                                                    {(Lit_Star '*') 
                                                                      (DQ (' ') 
                                                                        ($ VSub_DollarName 
'$temp_xrpath'
                                                                        ) (' ')
                                                                      ) (Lit_Star '*')
                                                                    }
                                                                  ]
                                                                )
                                                                (case_arm
                                                                  pat_list: [{(Lit_Star '*')}]
                                                                  action: [
                                                                    (C {(func_append)} {(xrpath)} 
                                                                      {
                                                                        (DQ (' ') 
                                                                          ($ VSub_DollarName 
'$temp_xrpath'
                                                                          )
                                                                        )
                                                                      }
                                                                    )
                                                                  ]
                                                                )
                                                              ]
                                                            )
                                                          ]
                                                        )
                                                        (case_arm
                                                          pat_list: [{(Lit_Star '*')}]
                                                          action: [
                                                            (C {(func_append)} {(temp_deplibs)} 
                                                              {
                                                                (DQ (' ') 
                                                                  ($ VSub_DollarName '$libdir')
                                                                )
                                                              }
                                                            )
                                                          ]
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                )
                                            )
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:dependency_libs)
                                                  op: Equal
                                                  rhs: {($ VSub_DollarName '$temp_deplibs')}
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                    (C {(func_append)} {(newlib_search_path)} 
                                      {(DQ (' ') ($ VSub_DollarName '$absdir'))}
                                    )
                                    (command.AndOr
                                      ops: [Op_DAmp]
                                      children: [
                                        (C {(test)} {(no)} {(Lit_Equals '=')} 
                                          {(DQ ($ VSub_DollarName '$link_static'))}
                                        )
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:newdependency_libs)
                                              op: Equal
                                              rhs: 
                                                {
                                                  (DQ ($ VSub_DollarName '$abs_ladir') (/) 
                                                    ($ VSub_DollarName '$laname') (' ') ($ VSub_DollarName '$newdependency_libs')
                                                  )
                                                }
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:tmp_libs)
                                          op: Equal
                                          rhs: (word.Empty)
                                        )
                                      ]
                                    )
                                    (command.ForEach
                                      iter_name: deplib
                                      iter_words: [{($ VSub_DollarName '$dependency_libs')}]
                                      do_arg_iter: F
                                      body: 
                                        (command.DoGroup
                                          children: [
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:newdependency_libs)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ ($ VSub_DollarName '$deplib') (' ') 
                                                        ($ VSub_DollarName '$newdependency_libs')
                                                      )
                                                    }
                                                )
                                              ]
                                            )
                                            (command.Case
                                              to_match: {($ VSub_DollarName '$deplib')}
                                              arms: [
                                                (case_arm
                                                  pat_list: [{(-L) (Lit_Star '*')}]
                                                  action: [
                                                    (C {(func_stripname)} {(SQ <-L>)} {(SQ )} 
                                                      {(DQ ($ VSub_DollarName '$deplib'))}
                                                    )
                                                    (C {(func_resolve_sysroot)} 
                                                      {
                                                        (DQ 
                                                          ($ VSub_DollarName '$func_stripname_result')
                                                        )
                                                      }
                                                    )
                                                  ]
                                                )
                                                (case_arm
                                                  pat_list: [{(Lit_Star '*')}]
                                                  action: [
                                                    (C {(func_resolve_sysroot)} 
                                                      {(DQ ($ VSub_DollarName '$deplib'))}
                                                    )
                                                  ]
                                                )
                                              ]
                                            )
                                            (command.If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (command.Sentence
                                                      child: 
                                                        (C 
                                                          {
                                                            ($ VSub_DollarName 
'$opt_preserve_dup_deps'
                                                            )
                                                          }
                                                        )
                                                      terminator: <Op_Semi ';'>
                                                    )
                                                  ]
                                                  action: [
                                                    (command.Case
                                                      to_match: 
                                                        {(DQ ($ VSub_DollarName '$tmp_libs') (' '))}
                                                      arms: [
                                                        (case_arm
                                                          pat_list: [
                                                            {(Lit_Star '*') 
                                                              (DQ (' ') 
                                                                ($ VSub_DollarName 
'$func_resolve_sysroot_result'
                                                                ) (' ')
                                                              ) (Lit_Star '*')
                                                            }
                                                          ]
                                                          action: [
                                                            (C {(func_append)} {(specialdeplibs)} 
                                                              {
                                                                (DQ (' ') 
                                                                  ($ VSub_DollarName 
'$func_resolve_sysroot_result'
                                                                  )
                                                                )
                                                              }
                                                            )
                                                          ]
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                )
                                              ]
                                            )
                                            (C {(func_append)} {(tmp_libs)} 
                                              {
                                                (DQ (' ') 
                                                  ($ VSub_DollarName '$func_resolve_sysroot_result')
                                                )
                                              }
                                            )
                                          ]
                                        )
                                    )
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (command.Sentence
                                              child: 
                                                (C {(test)} {(no)} {(KW_Bang '!') (Lit_Equals '=')} 
                                                  {(DQ ($ VSub_DollarName '$link_all_deplibs'))}
                                                )
                                              terminator: <Op_Semi ';'>
                                            )
                                          ]
                                          action: [
                                            (command.ForEach
                                              iter_name: deplib
                                              iter_words: [{($ VSub_DollarName '$dependency_libs')}]
                                              do_arg_iter: F
                                              body: 
                                                (command.DoGroup
                                                  children: [
                                                    (command.ShAssignment
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (sh_lhs_expr.Name name:path)
                                                          op: Equal
                                                          rhs: (word.Empty)
                                                        )
                                                      ]
                                                    )
                                                    (command.Case
                                                      to_match: {($ VSub_DollarName '$deplib')}
                                                      arms: [
                                                        (case_arm
                                                          pat_list: [{(-L) (Lit_Star '*')}]
                                                          action: [
                                                            (command.ShAssignment
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: (sh_lhs_expr.Name name:path)
                                                                  op: Equal
                                                                  rhs: {($ VSub_DollarName '$deplib')}
                                                                )
                                                              ]
                                                            )
                                                          ]
                                                        )
                                                        (case_arm
                                                          pat_list: [{(Lit_Star '*') (.la)}]
                                                          action: [
                                                            (C {(func_resolve_sysroot)} 
                                                              {(DQ ($ VSub_DollarName '$deplib'))}
                                                            )
                                                            (command.ShAssignment
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: (sh_lhs_expr.Name name:deplib)
                                                                  op: Equal
                                                                  rhs: 
                                                                    {
                                                                      ($ VSub_DollarName 
'$func_resolve_sysroot_result'
                                                                      )
                                                                    }
                                                                )
                                                              ]
                                                            )
                                                            (C {(func_dirname)} 
                                                              {(DQ ($ VSub_DollarName '$deplib'))} {(DQ )} {(DQ (.))}
                                                            )
                                                            (command.ShAssignment
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: (sh_lhs_expr.Name name:dir)
                                                                  op: Equal
                                                                  rhs: 
                                                                    {
                                                                      ($ VSub_DollarName 
'$func_dirname_result'
                                                                      )
                                                                    }
                                                                )
                                                              ]
                                                            )
                                                            (command.Case
                                                              to_match: {($ VSub_DollarName '$dir')}
                                                              arms: [
                                                                (case_arm
                                                                  pat_list: [
                                                                    {(Lit_LBracket '[') 
                                                                      (word_part.EscapedLiteral
                                                                        token: 
                                                                          <Lit_EscapedChar '\\\\'>
                                                                      ) (/) (Lit_RBracket ']') (Lit_Star '*')
                                                                    }
                                                                    {(Lit_LBracket '[') (A-Za-z) 
                                                                      (Lit_RBracket ']') (Lit_Other ':') (Lit_LBracket '[') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\\\'>) (/) 
                                                                      (Lit_RBracket ']') (Lit_Star '*')
                                                                    }
                                                                  ]
                                                                  action: [
                                                                    (command.ShAssignment
                                                                      pairs: [
                                                                        (assign_pair
                                                                          lhs: 
                                                                            (sh_lhs_expr.Name
                                                                              name: absdir
                                                                            )
                                                                          op: Equal
                                                                          rhs: 
                                                                            {
                                                                              ($ VSub_DollarName 
'$dir'
                                                                              )
                                                                            }
                                                                        )
                                                                      ]
                                                                    )
                                                                  ]
                                                                )
                                                                (case_arm
                                                                  pat_list: [{(Lit_Star '*')}]
                                                                  action: [
                                                                    (command.ShAssignment
                                                                      pairs: [
                                                                        (assign_pair
                                                                          lhs: 
                                                                            (sh_lhs_expr.Name
                                                                              name: absdir
                                                                            )
                                                                          op: Equal
                                                                          rhs: 
                                                                            {
                                                                              (command_sub
                                                                                left_token: 
                                                                                  <Left_Backtick '`'>
                                                                                command_list: 
                                                                                  (command.CommandList
                                                                                    children: [
                                                                                      (command.AndOr
                                                                                        ops: [
Op_DAmp
                                                                                        ]
                                                                                        children: [
                                                                                          (C {(cd)} 
                                                                                            {
                                                                                              (DQ 
                                                                                                ($ 
VSub_DollarName '$dir'
                                                                                                )
                                                                                              )
                                                                                            }
                                                                                          )
                                                                                          (C {(pwd)})
                                                                                        ]
                                                                                      )
                                                                                    ]
                                                                                  )
                                                                              )
                                                                            }
                                                                        )
                                                                      ]
                                                                    )
                                                                    (command.If
                                                                      arms: [
                                                                        (if_arm
                                                                          cond: [
                                                                            (command.Sentence
                                                                              child: 
                                                                                (C {(test)} {(-z)} 
                                                                                  {
                                                                                    (DQ 
                                                                                      ($ 
VSub_DollarName '$absdir'
                                                                                      )
                                                                                    )
                                                                                  }
                                                                                )
                                                                              terminator: 
                                                                                <Op_Semi ';'>
                                                                            )
                                                                          ]
                                                                          action: [
                                                                            (C {(func_warning)} 
                                                                              {
                                                                                (DQ 
                                                                                  (
"cannot determine absolute directory name of '"
                                                                                  ) ($ VSub_DollarName '$dir') ("'")
                                                                                )
                                                                              }
                                                                            )
                                                                            (command.ShAssignment
                                                                              pairs: [
                                                                                (assign_pair
                                                                                  lhs: 
                                                                                    (sh_lhs_expr.Name
                                                                                      name: absdir
                                                                                    )
                                                                                  op: Equal
                                                                                  rhs: 
                                                                                    {
                                                                                      ($ 
VSub_DollarName '$dir'
                                                                                      )
                                                                                    }
                                                                                )
                                                                              ]
                                                                            )
                                                                          ]
                                                                        )
                                                                      ]
                                                                    )
                                                                  ]
                                                                )
                                                              ]
                                                            )
                                                            (command.If
                                                              arms: [
                                                                (if_arm
                                                                  cond: [
                                                                    (command.Sentence
                                                                      child: 
                                                                        (command.Simple
                                                                          words: [
                                                                            {
                                                                              ($ VSub_DollarName 
'$GREP'
                                                                              )
                                                                            }
                                                                            {(DQ ('^installed=no'))}
                                                                            {
                                                                              ($ VSub_DollarName 
'$deplib'
                                                                              )
                                                                            }
                                                                          ]
                                                                          redirects: [
                                                                            (redir.Redir
                                                                              op: <Redir_Great '>'>
                                                                              fd: 16777215
                                                                              arg_word: {(/dev/null)}
                                                                            )
                                                                          ]
                                                                        )
                                                                      terminator: <Op_Semi ';'>
                                                                    )
                                                                  ]
                                                                  action: [
                                                                    (command.Case
                                                                      to_match: 
                                                                        {($ VSub_DollarName '$host')}
                                                                      arms: [
                                                                        (case_arm
                                                                          pat_list: [
                                                                            {(Lit_Star '*') (-) 
                                                                              (Lit_Star '*') (-darwin) (Lit_Star '*')
                                                                            }
                                                                          ]
                                                                          action: [
                                                                            (command.ShAssignment
                                                                              pairs: [
                                                                                (assign_pair
                                                                                  lhs: 
                                                                                    (sh_lhs_expr.Name
                                                                                      name: depdepl
                                                                                    )
                                                                                  op: Equal
                                                                                  rhs: (word.Empty)
                                                                                )
                                                                              ]
                                                                            )
                                                                            (C {(eval)} 
                                                                              {
                                                                                (Lit_VarLike 
'deplibrary_names='
                                                                                ) 
                                                                                (command_sub
                                                                                  left_token: 
                                                                                    <Left_Backtick 
'`'
                                                                                    >
                                                                                  command_list: 
                                                                                    (command.CommandList
                                                                                      children: [
                                                                                        (C 
                                                                                          {
                                                                                            ($ 
VSub_DollarName '$SED'
                                                                                            )
                                                                                          } {(-n)} {(-e)} {(SQ <'s/^library_names=\\(.*\\)$/\\1/p'>)} {($ VSub_DollarName '$deplib')}
                                                                                        )
                                                                                      ]
                                                                                    )
                                                                                )
                                                                              }
                                                                            )
                                                                            (command.If
                                                                              arms: [
                                                                                (if_arm
                                                                                  cond: [
                                                                                    (command.Sentence
                                                                                      child: 
                                                                                        (C {(test)} 
                                                                                          {(-n)} {(DQ ($ VSub_DollarName '$deplibrary_names'))}
                                                                                        )
                                                                                      terminator: 
                                                                                        <Op_Semi ';'>
                                                                                    )
                                                                                  ]
                                                                                  action: [
                                                                                    (command.ForEach
                                                                                      iter_name: tmp
                                                                                      iter_words: [
                                                                                        {
                                                                                          ($ 
VSub_DollarName '$deplibrary_names'
                                                                                          )
                                                                                        }
                                                                                      ]
                                                                                      do_arg_iter: F
                                                                                      body: 
                                                                                        (command.DoGroup
                                                                                          children: [
                                                                                            (command.ShAssignment
                                                                                              pairs: [
                                                                                                (assign_pair
                                                                                                  lhs: 
                                                                                                    (sh_lhs_expr.Name
                                                                                                      name: 
depdepl
                                                                                                    )
                                                                                                  op: 
Equal
                                                                                                  rhs: 
                                                                                                    {
                                                                                                      ($ 
VSub_DollarName '$tmp'
                                                                                                      )
                                                                                                    }
                                                                                                )
                                                                                              ]
                                                                                            )
                                                                                          ]
                                                                                        )
                                                                                    )
                                                                                    (command.If
                                                                                      arms: [
                                                                                        (if_arm
                                                                                          cond: [
                                                                                            (command.Sentence
                                                                                              child: 
                                                                                                (C 
                                                                                                  {
                                                                                                    (
test
                                                                                                    )
                                                                                                  } {(-f)} 
                                                                                                  {
                                                                                                    (DQ 
                                                                                                      ($ 
VSub_DollarName '$absdir'
                                                                                                      ) (/) ($ VSub_DollarName '$objdir') (/) ($ VSub_DollarName '$depdepl')
                                                                                                    )
                                                                                                  }
                                                                                                )
                                                                                              terminator: 
                                                                                                <
Op_Semi ';'
                                                                                                >
                                                                                            )
                                                                                          ]
                                                                                          action: [
                                                                                            (command.ShAssignment
                                                                                              pairs: [
                                                                                                (assign_pair
                                                                                                  lhs: 
                                                                                                    (sh_lhs_expr.Name
                                                                                                      name: 
depdepl
                                                                                                    )
                                                                                                  op: 
Equal
                                                                                                  rhs: 
                                                                                                    {
                                                                                                      ($ 
VSub_DollarName '$absdir'
                                                                                                      ) (/) ($ VSub_DollarName '$objdir') (/) ($ VSub_DollarName '$depdepl')
                                                                                                    }
                                                                                                )
                                                                                              ]
                                                                                            )
                                                                                            (command.ShAssignment
                                                                                              pairs: [
                                                                                                (assign_pair
                                                                                                  lhs: 
                                                                                                    (sh_lhs_expr.Name
                                                                                                      name: 
darwin_install_name
                                                                                                    )
                                                                                                  op: 
Equal
                                                                                                  rhs: 
                                                                                                    {
                                                                                                      (command_sub
                                                                                                        left_token: 
                                                                                                          <
Left_Backtick '`'
                                                                                                          >
                                                                                                        command_list: 
                                                                                                          (command.CommandList
                                                                                                            children: [
                                                                                                              (command.Pipeline
                                                                                                                children: [
                                                                                                                  (C 
                                                                                                                    {
                                                                                                                      ($ 
VSub_DollarName '$OTOOL'
                                                                                                                      )
                                                                                                                    } {(-L)} {($ VSub_DollarName '$depdepl')}
                                                                                                                  )
                                                                                                                  (C 
                                                                                                                    {
                                                                                                                      (
awk
                                                                                                                      )
                                                                                                                    } {(SQ <'{if (NR == 2) {print $1;exit}}'>)}
                                                                                                                  )
                                                                                                                ]
                                                                                                                negated: 
F
                                                                                                              )
                                                                                                            ]
                                                                                                          )
                                                                                                      )
                                                                                                    }
                                                                                                )
                                                                                              ]
                                                                                            )
                                                                                            (command.If
                                                                                              arms: [
                                                                                                (if_arm
                                                                                                  cond: [
                                                                                                    (command.Sentence
                                                                                                      child: 
                                                                                                        (C 
                                                                                                          {
                                                                                                            (
test
                                                                                                            )
                                                                                                          } {(-z)} {(DQ ($ VSub_DollarName '$darwin_install_name'))}
                                                                                                        )
                                                                                                      terminator: 
                                                                                                        <
Op_Semi ';'
                                                                                                        >
                                                                                                    )
                                                                                                  ]
                                                                                                  action: [
                                                                                                    (command.ShAssignment
                                                                                                      pairs: [
                                                                                                        (assign_pair
                                                                                                          lhs: 
                                                                                                            (sh_lhs_expr.Name
                                                                                                              name: 
darwin_install_name
                                                                                                            )
                                                                                                          op: 
Equal
                                                                                                          rhs: 
                                                                                                            {
                                                                                                              (command_sub
                                                                                                                left_token: 
                                                                                                                  <
Left_Backtick '`'
                                                                                                                  >
                                                                                                                command_list: 
                                                                                                                  (command.CommandList
                                                                                                                    children: [
                                                                                                                      (command.Pipeline
                                                                                                                        children: [
                                                                                                                          (C 
                                                                                                                            {
                                                                                                                              ($ 
VSub_DollarName '$OTOOL64'
                                                                                                                              )
                                                                                                                            } {(-L)} {($ VSub_DollarName '$depdepl')}
                                                                                                                          )
                                                                                                                          (C 
                                                                                                                            {
                                                                                                                              (
awk
                                                                                                                              )
                                                                                                                            } {(SQ <'{if (NR == 2) {print $1;exit}}'>)}
                                                                                                                          )
                                                                                                                        ]
                                                                                                                        negated: 
F
                                                                                                                      )
                                                                                                                    ]
                                                                                                                  )
                                                                                                              )
                                                                                                            }
                                                                                                        )
                                                                                                      ]
                                                                                                    )
                                                                                                  ]
                                                                                                )
                                                                                              ]
                                                                                            )
                                                                                            (C 
                                                                                              {
                                                                                                (
func_append
                                                                                                )
                                                                                              } {(compiler_flags)} 
                                                                                              {
                                                                                                (DQ 
                                                                                                  (
' '
                                                                                                  ) ($ VSub_DollarName '$wl') ('-dylib_file ') ($ VSub_DollarName '$wl') 
                                                                                                  ($ 
VSub_DollarName '$darwin_install_name'
                                                                                                  ) (':') ($ VSub_DollarName '$depdepl')
                                                                                                )
                                                                                              }
                                                                                            )
                                                                                            (C 
                                                                                              {
                                                                                                (
func_append
                                                                                                )
                                                                                              } {(linker_flags)} 
                                                                                              {
                                                                                                (DQ 
                                                                                                  (
' -dylib_file '
                                                                                                  ) ($ VSub_DollarName '$darwin_install_name') (':') ($ VSub_DollarName '$depdepl')
                                                                                                )
                                                                                              }
                                                                                            )
                                                                                            (command.ShAssignment
                                                                                              pairs: [
                                                                                                (assign_pair
                                                                                                  lhs: 
                                                                                                    (sh_lhs_expr.Name
                                                                                                      name: 
path
                                                                                                    )
                                                                                                  op: 
Equal
                                                                                                  rhs: (word.Empty)
                                                                                                )
                                                                                              ]
                                                                                            )
                                                                                          ]
                                                                                        )
                                                                                      ]
                                                                                    )
                                                                                  ]
                                                                                )
                                                                              ]
                                                                            )
                                                                          ]
                                                                        )
                                                                        (case_arm
                                                                          pat_list: [{(Lit_Star '*')}]
                                                                          action: [
                                                                            (command.ShAssignment
                                                                              pairs: [
                                                                                (assign_pair
                                                                                  lhs: 
                                                                                    (sh_lhs_expr.Name
                                                                                      name: path
                                                                                    )
                                                                                  op: Equal
                                                                                  rhs: 
                                                                                    {(-L) 
                                                                                      ($ 
VSub_DollarName '$absdir'
                                                                                      ) (/) ($ VSub_DollarName '$objdir')
                                                                                    }
                                                                                )
                                                                              ]
                                                                            )
                                                                          ]
                                                                        )
                                                                      ]
                                                                    )
                                                                  ]
                                                                )
                                                              ]
                                                              else_action: [
                                                                (C {(eval)} 
                                                                  {(Lit_VarLike 'libdir=') 
                                                                    (command_sub
                                                                      left_token: <Left_Backtick '`'>
                                                                      command_list: 
                                                                        (command.CommandList
                                                                          children: [
                                                                            (C 
                                                                              {
                                                                                ($ VSub_DollarName 
'$SED'
                                                                                )
                                                                              } {(-n)} {(-e)} {(SQ <'s/^libdir=\\(.*\\)$/\\1/p'>)} {($ VSub_DollarName '$deplib')}
                                                                            )
                                                                          ]
                                                                        )
                                                                    )
                                                                  }
                                                                )
                                                                (command.AndOr
                                                                  ops: [Op_DAmp]
                                                                  children: [
                                                                    (C {(test)} {(-z)} 
                                                                      {
                                                                        (DQ 
                                                                          ($ VSub_DollarName 
'$libdir'
                                                                          )
                                                                        )
                                                                      }
                                                                    )
                                                                    (C {(func_fatal_error)} 
                                                                      {
                                                                        (DQ ("'") 
                                                                          ($ VSub_DollarName 
'$deplib'
                                                                          ) ("' is not a valid libtool archive")
                                                                        )
                                                                      }
                                                                    )
                                                                  ]
                                                                )
                                                                (command.AndOr
                                                                  ops: [Op_DAmp]
                                                                  children: [
                                                                    (C {(test)} 
                                                                      {
                                                                        (DQ 
                                                                          ($ VSub_DollarName 
'$absdir'
                                                                          )
                                                                        )
                                                                      } {(KW_Bang '!') (Lit_Equals '=')} {(DQ ($ VSub_DollarName '$libdir'))}
                                                                    )
                                                                    (C {(func_warning)} 
                                                                      {
                                                                        (DQ ("'") 
                                                                          ($ VSub_DollarName 
'$deplib'
                                                                          ) ("' seems to be moved")
                                                                        )
                                                                      }
                                                                    )
                                                                  ]
                                                                )
                                                                (command.ShAssignment
                                                                  pairs: [
                                                                    (assign_pair
                                                                      lhs: 
                                                                        (sh_lhs_expr.Name
                                                                          name: path
                                                                        )
                                                                      op: Equal
                                                                      rhs: 
                                                                        {(-L) 
                                                                          ($ VSub_DollarName 
'$absdir'
                                                                          )
                                                                        }
                                                                    )
                                                                  ]
                                                                )
                                                              ]
                                                            )
                                                          ]
                                                        )
                                                      ]
                                                    )
                                                    (command.Case
                                                      to_match: 
                                                        {
                                                          (DQ (' ') ($ VSub_DollarName '$deplibs') 
                                                            (' ')
                                                          )
                                                        }
                                                      arms: [
                                                        (case_arm
                                                          pat_list: [
                                                            {(Lit_Star '*') 
                                                              (DQ (' ') ($ VSub_DollarName '$path') 
                                                                (' ')
                                                              ) (Lit_Star '*')
                                                            }
                                                          ]
                                                        )
                                                        (case_arm
                                                          pat_list: [{(Lit_Star '*')}]
                                                          action: [
                                                            (command.ShAssignment
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: 
                                                                    (sh_lhs_expr.Name
                                                                      name: deplibs
                                                                    )
                                                                  op: Equal
                                                                  rhs: 
                                                                    {
                                                                      (DQ ($ VSub_DollarName '$path') 
                                                                        (' ') ($ VSub_DollarName '$deplibs')
                                                                      )
                                                                    }
                                                                )
                                                              ]
                                                            )
                                                          ]
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                )
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                            )
                          ]
                        )
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: 
                                (C {(test)} {(link)} {(Lit_Equals '=')} {(DQ ($ VSub_DollarName '$pass'))})
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (C {(test)} {(prog)} {(Lit_Equals '=')} 
                                          {(DQ ($ VSub_DollarName '$linkmode'))}
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:compile_deplibs)
                                          op: Equal
                                          rhs: 
                                            {
                                              (DQ ($ VSub_DollarName '$new_inherited_linker_flags') 
                                                (' ') ($ VSub_DollarName '$compile_deplibs')
                                              )
                                            }
                                        )
                                      ]
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:finalize_deplibs)
                                          op: Equal
                                          rhs: 
                                            {
                                              (DQ ($ VSub_DollarName '$new_inherited_linker_flags') 
                                                (' ') ($ VSub_DollarName '$finalize_deplibs')
                                              )
                                            }
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                              else_action: [
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:compiler_flags)
                                      op: Equal
                                      rhs: 
                                        {(DQ ($ VSub_DollarName '$compiler_flags') (' ')) 
                                          (command_sub
                                            left_token: <Left_Backtick '`'>
                                            command_list: 
                                              (command.CommandList
                                                children: [
                                                  (command.Pipeline
                                                    children: [
                                                      (C {($ VSub_DollarName '$ECHO')} 
                                                        {
                                                          (DQ (' ') 
                                                            ($ VSub_DollarName 
'$new_inherited_linker_flags'
                                                            )
                                                          )
                                                        }
                                                      )
                                                      (C {($ VSub_DollarName '$SED')} 
                                                        {
                                                          (SQ 
                                                            <
's% \\([^ $]*\\).ltframework% -framework \\1%g'
                                                            >
                                                          )
                                                        }
                                                      )
                                                    ]
                                                    negated: F
                                                  )
                                                ]
                                              )
                                          )
                                        }
                                    )
                                  ]
                                )
                              ]
                            )
                          ]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:dependency_libs)
                          op: Equal
                          rhs: {($ VSub_DollarName '$newdependency_libs')}
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: 
                                (C {(test)} {(dlpreopen)} {(Lit_Equals '=')} 
                                  {(DQ ($ VSub_DollarName '$pass'))}
                                )
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [
                            (command.ForEach
                              iter_name: deplib
                              iter_words: [{($ VSub_DollarName '$save_deplibs')}]
                              do_arg_iter: F
                              body: 
                                (command.DoGroup
                                  children: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:deplibs)
                                          op: Equal
                                          rhs: 
                                            {
                                              (DQ ($ VSub_DollarName '$deplib') (' ') 
                                                ($ VSub_DollarName '$deplibs')
                                              )
                                            }
                                        )
                                      ]
                                    )
                                  ]
                                )
                            )
                          ]
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: 
                                (C {(test)} {(dlopen)} {(KW_Bang '!') (Lit_Equals '=')} 
                                  {(DQ ($ VSub_DollarName '$pass'))}
                                )
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [
                            (command.AndOr
                              ops: [Op_DPipe]
                              children: [
                                (C {(test)} {(conv)} {(Lit_Equals '=')} {(DQ ($ VSub_DollarName '$pass'))})
                                (command.BraceGroup
                                  children: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:lib_search_path)
                                          op: Equal
                                          rhs: (word.Empty)
                                        )
                                      ]
                                    )
                                    (command.ForEach
                                      iter_name: dir
                                      iter_words: [{($ VSub_DollarName '$newlib_search_path')}]
                                      do_arg_iter: F
                                      body: 
                                        (command.DoGroup
                                          children: [
                                            (command.Case
                                              to_match: 
                                                {(DQ ($ VSub_DollarName '$lib_search_path') (' '))}
                                              arms: [
                                                (case_arm
                                                  pat_list: [
                                                    {(Lit_Star '*') 
                                                      (DQ (' ') ($ VSub_DollarName '$dir') (' ')) (Lit_Star '*')
                                                    }
                                                  ]
                                                )
                                                (case_arm
                                                  pat_list: [{(Lit_Star '*')}]
                                                  action: [
                                                    (C {(func_append)} {(lib_search_path)} 
                                                      {(DQ (' ') ($ VSub_DollarName '$dir'))}
                                                    )
                                                  ]
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:newlib_search_path)
                                          op: Equal
                                          rhs: (word.Empty)
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (C {(test)} {(prog) (Lit_Comma ',') (link)} {(Lit_Equals '=')} 
                                          {
                                            (DQ ($ VSub_DollarName '$linkmode') (',') 
                                              ($ VSub_DollarName '$pass')
                                            )
                                          }
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:vars)
                                          op: Equal
                                          rhs: {(DQ ('compile_deplibs finalize_deplibs'))}
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                              else_action: [
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:vars)
                                      op: Equal
                                      rhs: {(deplibs)}
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.ForEach
                              iter_name: var
                              iter_words: [{($ VSub_DollarName '$vars')} {(dependency_libs)}]
                              do_arg_iter: F
                              body: 
                                (command.DoGroup
                                  children: [
                                    (C {(eval)} 
                                      {(Lit_VarLike 'tmp_libs=') 
                                        (word_part.EscapedLiteral
                                          token: <Lit_EscapedChar '\\"'>
                                        ) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) ($ VSub_DollarName '$var') 
                                        (word_part.EscapedLiteral
                                          token: <Lit_EscapedChar '\\"'>
                                        )
                                      }
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:new_libs)
                                          op: Equal
                                          rhs: (word.Empty)
                                        )
                                      ]
                                    )
                                    (command.ForEach
                                      iter_name: deplib
                                      iter_words: [{($ VSub_DollarName '$tmp_libs')}]
                                      do_arg_iter: F
                                      body: 
                                        (command.DoGroup
                                          children: [
                                            (command.Case
                                              to_match: {($ VSub_DollarName '$deplib')}
                                              arms: [
                                                (case_arm
                                                  pat_list: [{(-L) (Lit_Star '*')}]
                                                  action: [
                                                    (command.ShAssignment
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (sh_lhs_expr.Name name:new_libs)
                                                          op: Equal
                                                          rhs: 
                                                            {
                                                              (DQ ($ VSub_DollarName '$deplib') (' ') 
                                                                ($ VSub_DollarName '$new_libs')
                                                              )
                                                            }
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                )
                                                (case_arm
                                                  pat_list: [{(-R) (Lit_Star '*')}]
                                                )
                                                (case_arm
                                                  pat_list: [{(Lit_Star '*')}]
                                                  action: [
                                                    (command.Case
                                                      to_match: 
                                                        {
                                                          (DQ (' ') 
                                                            ($ VSub_DollarName '$specialdeplibs') (' ')
                                                          )
                                                        }
                                                      arms: [
                                                        (case_arm
                                                          pat_list: [
                                                            {(Lit_Star '*') 
                                                              (DQ (' ') ($ VSub_DollarName '$deplib') 
                                                                (' ')
                                                              ) (Lit_Star '*')
                                                            }
                                                          ]
                                                          action: [
                                                            (command.ShAssignment
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: 
                                                                    (sh_lhs_expr.Name
                                                                      name: new_libs
                                                                    )
                                                                  op: Equal
                                                                  rhs: 
                                                                    {
                                                                      (DQ 
                                                                        ($ VSub_DollarName '$deplib') (' ') ($ VSub_DollarName '$new_libs')
                                                                      )
                                                                    }
                                                                )
                                                              ]
                                                            )
                                                          ]
                                                        )
                                                        (case_arm
                                                          pat_list: [{(Lit_Star '*')}]
                                                          action: [
                                                            (command.Case
                                                              to_match: 
                                                                {
                                                                  (DQ (' ') 
                                                                    ($ VSub_DollarName '$new_libs') (' ')
                                                                  )
                                                                }
                                                              arms: [
                                                                (case_arm
                                                                  pat_list: [
                                                                    {(Lit_Star '*') 
                                                                      (DQ (' ') 
                                                                        ($ VSub_DollarName '$deplib') (' ')
                                                                      ) (Lit_Star '*')
                                                                    }
                                                                  ]
                                                                )
                                                                (case_arm
                                                                  pat_list: [{(Lit_Star '*')}]
                                                                  action: [
                                                                    (command.ShAssignment
                                                                      pairs: [
                                                                        (assign_pair
                                                                          lhs: 
                                                                            (sh_lhs_expr.Name
                                                                              name: new_libs
                                                                            )
                                                                          op: Equal
                                                                          rhs: 
                                                                            {
                                                                              (DQ 
                                                                                ($ VSub_DollarName 
'$deplib'
                                                                                ) (' ') ($ VSub_DollarName '$new_libs')
                                                                              )
                                                                            }
                                                                        )
                                                                      ]
                                                                    )
                                                                  ]
                                                                )
                                                              ]
                                                            )
                                                          ]
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:tmp_libs)
                                          op: Equal
                                          rhs: (word.Empty)
                                        )
                                      ]
                                    )
                                    (command.ForEach
                                      iter_name: deplib
                                      iter_words: [{($ VSub_DollarName '$new_libs')}]
                                      do_arg_iter: F
                                      body: 
                                        (command.DoGroup
                                          children: [
                                            (command.Case
                                              to_match: {($ VSub_DollarName '$deplib')}
                                              arms: [
                                                (case_arm
                                                  pat_list: [{(-L) (Lit_Star '*')}]
                                                  action: [
                                                    (command.Case
                                                      to_match: 
                                                        {
                                                          (DQ (' ') ($ VSub_DollarName '$tmp_libs') 
                                                            (' ')
                                                          )
                                                        }
                                                      arms: [
                                                        (case_arm
                                                          pat_list: [
                                                            {(Lit_Star '*') 
                                                              (DQ (' ') ($ VSub_DollarName '$deplib') 
                                                                (' ')
                                                              ) (Lit_Star '*')
                                                            }
                                                          ]
                                                        )
                                                        (case_arm
                                                          pat_list: [{(Lit_Star '*')}]
                                                          action: [
                                                            (C {(func_append)} {(tmp_libs)} 
                                                              {
                                                                (DQ (' ') 
                                                                  ($ VSub_DollarName '$deplib')
                                                                )
                                                              }
                                                            )
                                                          ]
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                )
                                                (case_arm
                                                  pat_list: [{(Lit_Star '*')}]
                                                  action: [
                                                    (C {(func_append)} {(tmp_libs)} 
                                                      {(DQ (' ') ($ VSub_DollarName '$deplib'))}
                                                    )
                                                  ]
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                    )
                                    (C {(eval)} 
                                      {($ VSub_DollarName '$var') (Lit_Equals '=') 
                                        (word_part.EscapedLiteral
                                          token: <Lit_EscapedChar '\\"'>
                                        ) ($ VSub_DollarName '$tmp_libs') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>)
                                      }
                                    )
                                  ]
                                )
                            )
                          ]
                        )
                      ]
                    )
                    (command.AndOr
                      ops: [Op_DAmp]
                      children: [
                        (C {(test)} {(CXX)} {(Lit_Equals '=')} {(DQ ($ VSub_DollarName '$tagname'))})
                        (command.BraceGroup
                          children: [
                            (command.Case
                              to_match: {($ VSub_DollarName '$host_os')}
                              arms: [
                                (case_arm
                                  pat_list: [{(linux) (Lit_Star '*')}]
                                  action: [
                                    (command.Case
                                      to_match: 
                                        {
                                          (command_sub
                                            left_token: <Left_Backtick '`'>
                                            command_list: 
                                              (command.CommandList
                                                children: [
                                                  (command.Pipeline
                                                    children: [
                                                      (command.Simple
                                                        words: [{($ VSub_DollarName '$CC')} {(-V)}]
                                                        redirects: [
                                                          (redir.Redir
                                                            op: <Redir_GreatAnd '2>&'>
                                                            fd: 2
                                                            arg_word: {(1)}
                                                          )
                                                        ]
                                                      )
                                                      (C {(sed)} {(5q)})
                                                    ]
                                                    negated: F
                                                  )
                                                ]
                                              )
                                          )
                                        }
                                      arms: [
                                        (case_arm
                                          pat_list: [
                                            {(Lit_Star '*') (Sun) 
                                              (word_part.EscapedLiteral
                                                token: <Lit_EscapedChar '\\ '>
                                              ) (C) (Lit_Star '*')
                                            }
                                          ]
                                          action: [
                                            (C {(func_suncc_cstd_abi)})
                                            (command.If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (command.Sentence
                                                      child: 
                                                        (C {(test)} {(no)} 
                                                          {(KW_Bang '!') (Lit_Equals '=')} {(DQ ($ VSub_DollarName '$suncc_use_cstd_abi'))}
                                                        )
                                                      terminator: <Op_Semi ';'>
                                                    )
                                                  ]
                                                  action: [
                                                    (C {(func_append)} {(postdeps)} 
                                                      {(SQ <' -library=Cstd -library=Crun'>)}
                                                    )
                                                  ]
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                  ]
                                )
                                (case_arm
                                  pat_list: [{(solaris) (Lit_Star '*')}]
                                  action: [
                                    (C {(func_cc_basename)} {(DQ ($ VSub_DollarName '$CC'))})
                                    (command.Case
                                      to_match: {($ VSub_DollarName '$func_cc_basename_result')}
                                      arms: [
                                        (case_arm
                                          pat_list: [{(CC) (Lit_Star '*')} {(sunCC) (Lit_Star '*')}]
                                          action: [
                                            (C {(func_suncc_cstd_abi)})
                                            (command.If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (command.Sentence
                                                      child: 
                                                        (C {(test)} {(no)} 
                                                          {(KW_Bang '!') (Lit_Equals '=')} {(DQ ($ VSub_DollarName '$suncc_use_cstd_abi'))}
                                                        )
                                                      terminator: <Op_Semi ';'>
                                                    )
                                                  ]
                                                  action: [
                                                    (C {(func_append)} {(postdeps)} 
                                                      {(SQ <' -library=Cstd -library=Crun'>)}
                                                    )
                                                  ]
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                            )
                          ]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:tmp_libs) op:Equal rhs:(word.Empty))]
                    )
                    (command.ForEach
                      iter_name: i
                      iter_words: [{($ VSub_DollarName '$dependency_libs')}]
                      do_arg_iter: F
                      body: 
                        (command.DoGroup
                          children: [
                            (command.Case
                              to_match: 
                                {
                                  (DQ (' ') ($ VSub_DollarName '$predeps') (' ') 
                                    ($ VSub_DollarName '$postdeps') (' ') ($ VSub_DollarName '$compiler_lib_search_path') (' ')
                                  )
                                }
                              arms: [
                                (case_arm
                                  pat_list: [
                                    {(Lit_Star '*') (DQ (' ') ($ VSub_DollarName '$i') (' ')) 
                                      (Lit_Star '*')
                                    }
                                  ]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:i) op:Equal rhs:(word.Empty))]
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$i'))})
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (C {(func_append)} {(tmp_libs)} {(DQ (' ') ($ VSub_DollarName '$i'))})
                                  ]
                                )
                              ]
                            )
                          ]
                        )
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:dependency_libs)
                          op: Equal
                          rhs: {($ VSub_DollarName '$tmp_libs')}
                        )
                      ]
                    )
                  ]
                )
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: 
                        (C {(test)} {(prog)} {(Lit_Equals '=')} {(DQ ($ VSub_DollarName '$linkmode'))})
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:dlfiles)
                          op: Equal
                          rhs: {($ VSub_DollarName '$newdlfiles')}
                        )
                      ]
                    )
                  ]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: 
                        (command.AndOr
                          ops: [Op_DPipe]
                          children: [
                            (C {(test)} {(prog)} {(Lit_Equals '=')} {(DQ ($ VSub_DollarName '$linkmode'))})
                            (C {(test)} {(lib)} {(Lit_Equals '=')} {(DQ ($ VSub_DollarName '$linkmode'))})
                          ]
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:dlprefiles)
                          op: Equal
                          rhs: {($ VSub_DollarName '$newdlprefiles')}
                        )
                      ]
                    )
                  ]
                )
              ]
            )
            (command.Case
              to_match: {($ VSub_DollarName '$linkmode')}
              arms: [
                (case_arm
                  pat_list: [{(oldlib)}]
                  action: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: 
                                (command.AndOr
                                  ops: [Op_DPipe]
                                  children: [
                                    (C {(test)} {(-n)} 
                                      {
                                        (DQ ($ VSub_DollarName '$dlfiles') 
                                          ($ VSub_DollarName '$dlprefiles')
                                        )
                                      }
                                    )
                                    (C {(test)} {(no)} {(KW_Bang '!') (Lit_Equals '=')} 
                                      {(DQ ($ VSub_DollarName '$dlself'))}
                                    )
                                  ]
                                )
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [(C {(func_warning)} {(DQ ("'-dlopen' is ignored for archives"))})]
                        )
                      ]
                    )
                    (command.Case
                      to_match: {(DQ (' ') ($ VSub_DollarName '$deplibs'))}
                      arms: [
                        (case_arm
                          pat_list: [
                            {(Lit_Star '*') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\ '>) 
                              (-l) (Lit_Star '*')
                            }
                            {(Lit_Star '*') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\ '>) 
                              (-L) (Lit_Star '*')
                            }
                          ]
                          action: [
                            (C {(func_warning)} {(DQ ("'-l' and '-L' are ignored for archives"))})
                          ]
                        )
                      ]
                    )
                    (command.AndOr
                      ops: [Op_DAmp]
                      children: [
                        (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$rpath'))})
                        (C {(func_warning)} {(DQ ("'-rpath' is ignored for archives"))})
                      ]
                    )
                    (command.AndOr
                      ops: [Op_DAmp]
                      children: [
                        (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$xrpath'))})
                        (C {(func_warning)} {(DQ ("'-R' is ignored for archives"))})
                      ]
                    )
                    (command.AndOr
                      ops: [Op_DAmp]
                      children: [
                        (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$vinfo'))})
                        (C {(func_warning)} 
                          {(DQ ("'-version-info/-version-number' is ignored for archives"))}
                        )
                      ]
                    )
                    (command.AndOr
                      ops: [Op_DAmp]
                      children: [
                        (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$release'))})
                        (C {(func_warning)} {(DQ ("'-release' is ignored for archives"))})
                      ]
                    )
                    (command.AndOr
                      ops: [Op_DAmp]
                      children: [
                        (C {(test)} {(-n)} 
                          {
                            (DQ ($ VSub_DollarName '$export_symbols') 
                              ($ VSub_DollarName '$export_symbols_regex')
                            )
                          }
                        )
                        (C {(func_warning)} {(DQ ("'-export-symbols' is ignored for archives"))})
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:build_libtool_libs)
                          op: Equal
                          rhs: {(no)}
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:oldlibs)
                          op: Equal
                          rhs: {($ VSub_DollarName '$output')}
                        )
                      ]
                    )
                    (C {(func_append)} {(objs)} {(DQ ($ VSub_DollarName '$old_deplibs'))})
                  ]
                )
                (case_arm
                  pat_list: [{(lib)}]
                  action: [
                    (command.Case
                      to_match: {($ VSub_DollarName '$outputname')}
                      arms: [
                        (case_arm
                          pat_list: [{(lib) (Lit_Star '*')}]
                          action: [
                            (C {(func_stripname)} {(SQ <lib>)} {(SQ <.la>)} 
                              {(DQ ($ VSub_DollarName '$outputname'))}
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:name)
                                  op: Equal
                                  rhs: {($ VSub_DollarName '$func_stripname_result')}
                                )
                              ]
                            )
                            (C {(eval)} 
                              {(Lit_VarLike 'shared_ext=') 
                                (word_part.EscapedLiteral
                                  token: <Lit_EscapedChar '\\"'>
                                ) ($ VSub_DollarName '$shrext_cmds') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>)
                              }
                            )
                            (C {(eval)} 
                              {(Lit_VarLike 'libname=') 
                                (word_part.EscapedLiteral
                                  token: <Lit_EscapedChar '\\"'>
                                ) ($ VSub_DollarName '$libname_spec') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>)
                              }
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(Lit_Star '*')}]
                          action: [
                            (command.AndOr
                              ops: [Op_DAmp]
                              children: [
                                (C {(test)} {(no)} {(Lit_Equals '=')} {(DQ ($ VSub_DollarName '$module'))})
                                (C {(func_fatal_help)} 
                                  {
                                    (DQ ("libtool library '") ($ VSub_DollarName '$output') 
                                      ("' must begin with 'lib'")
                                    )
                                  }
                                )
                              ]
                            )
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (C {(test)} {(no)} {(KW_Bang '!') (Lit_Equals '=')} 
                                          {(DQ ($ VSub_DollarName '$need_lib_prefix'))}
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (C {(func_stripname)} {(SQ )} {(SQ <.la>)} 
                                      {(DQ ($ VSub_DollarName '$outputname'))}
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:name)
                                          op: Equal
                                          rhs: {($ VSub_DollarName '$func_stripname_result')}
                                        )
                                      ]
                                    )
                                    (C {(eval)} 
                                      {(Lit_VarLike 'shared_ext=') 
                                        (word_part.EscapedLiteral
                                          token: <Lit_EscapedChar '\\"'>
                                        ) ($ VSub_DollarName '$shrext_cmds') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>)
                                      }
                                    )
                                    (C {(eval)} 
                                      {(Lit_VarLike 'libname=') 
                                        (word_part.EscapedLiteral
                                          token: <Lit_EscapedChar '\\"'>
                                        ) ($ VSub_DollarName '$libname_spec') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>)
                                      }
                                    )
                                  ]
                                )
                              ]
                              else_action: [
                                (C {(func_stripname)} {(SQ )} {(SQ <.la>)} 
                                  {(DQ ($ VSub_DollarName '$outputname'))}
                                )
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:libname)
                                      op: Equal
                                      rhs: {($ VSub_DollarName '$func_stripname_result')}
                                    )
                                  ]
                                )
                              ]
                            )
                          ]
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$objs'))})
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (C {(test)} {(pass_all)} {(KW_Bang '!') (Lit_Equals '=')} 
                                          {(DQ ($ VSub_DollarName '$deplibs_check_method'))}
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (C {(func_fatal_error)} 
                                      {
                                        (DQ ("cannot build libtool library '") 
                                          ($ VSub_DollarName '$output') ("' from non-libtool objects on this host:") ($ VSub_DollarName '$objs')
                                        )
                                      }
                                    )
                                  ]
                                )
                              ]
                              else_action: [
                                (C {(echo)})
                                (C {($ VSub_DollarName '$ECHO')} 
                                  {
                                    (DQ ('*** Warning: Linking the shared library ') 
                                      ($ VSub_DollarName '$output') (' against the non-libtool')
                                    )
                                  }
                                )
                                (C {($ VSub_DollarName '$ECHO')} 
                                  {
                                    (DQ ('*** objects ') ($ VSub_DollarName '$objs') 
                                      (' is not portable!')
                                    )
                                  }
                                )
                                (C {(func_append)} {(libobjs)} {(DQ (' ') ($ VSub_DollarName '$objs'))})
                              ]
                            )
                          ]
                        )
                      ]
                    )
                    (command.AndOr
                      ops: [Op_DPipe]
                      children: [
                        (C {(test)} {(no)} {(Lit_Equals '=')} {(DQ ($ VSub_DollarName '$dlself'))})
                        (C {(func_warning)} {(DQ ("'-dlopen self' is ignored for libtool libraries"))})
                      ]
                    )
                    (C {(KW_Set set)} {(dummy)} {($ VSub_DollarName '$rpath')})
                    (C {(shift)})
                    (command.AndOr
                      ops: [Op_DAmp]
                      children: [
                        (C {(test)} {(1)} {(-lt)} {(DQ ($ VSub_Pound '$#'))})
                        (C {(func_warning)} {(DQ ("ignoring multiple '-rpath's for a libtool library"))})
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:install_libdir)
                          op: Equal
                          rhs: {($ VSub_Number '$1')}
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:oldlibs) op:Equal rhs:(word.Empty))]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: (C {(test)} {(-z)} {(DQ ($ VSub_DollarName '$rpath'))})
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (C {(test)} {(yes)} {(Lit_Equals '=')} 
                                          {(DQ ($ VSub_DollarName '$build_libtool_libs'))}
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:oldlibs)
                                          op: Equal
                                          rhs: 
                                            {
                                              (DQ ($ VSub_DollarName '$output_objdir') (/) 
                                                ($ VSub_DollarName '$libname') (.) ($ VSub_DollarName '$libext') (' ') ($ VSub_DollarName '$oldlibs')
                                              )
                                            }
                                        )
                                      ]
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:build_libtool_libs)
                                          op: Equal
                                          rhs: {(convenience)}
                                        )
                                      ]
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:build_old_libs)
                                          op: Equal
                                          rhs: {(yes)}
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.AndOr
                              ops: [Op_DAmp]
                              children: [
                                (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$vinfo'))})
                                (C {(func_warning)} 
                                  {
                                    (DQ 
                                      (
"'-version-info/-version-number' is ignored for convenience libraries"
                                      )
                                    )
                                  }
                                )
                              ]
                            )
                            (command.AndOr
                              ops: [Op_DAmp]
                              children: [
                                (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$release'))})
                                (C {(func_warning)} 
                                  {(DQ ("'-release' is ignored for convenience libraries"))}
                                )
                              ]
                            )
                          ]
                        )
                      ]
                      else_action: [
                        (command.Sentence
                          child: 
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:save_ifs)
                                  op: Equal
                                  rhs: {($ VSub_DollarName '$IFS')}
                                )
                              ]
                            )
                          terminator: <Op_Semi ';'>
                        )
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:IFS)
                              op: Equal
                              rhs: {(Lit_Other ':')}
                            )
                          ]
                        )
                        (C {(KW_Set set)} {(dummy)} {($ VSub_DollarName '$vinfo')} {(0)} {(0)} {(0)})
                        (C {(shift)})
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:IFS)
                              op: Equal
                              rhs: {($ VSub_DollarName '$save_ifs')}
                            )
                          ]
                        )
                        (command.AndOr
                          ops: [Op_DAmp]
                          children: [
                            (C {(test)} {(-n)} {(DQ ($ VSub_Number '$7'))})
                            (C {(func_fatal_help)} {(DQ ("too many parameters to '-version-info'"))})
                          ]
                        )
                        (command.Case
                          to_match: {($ VSub_DollarName '$vinfo_number')}
                          arms: [
                            (case_arm
                              pat_list: [{(yes)}]
                              action: [
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:number_major)
                                      op: Equal
                                      rhs: {($ VSub_Number '$1')}
                                    )
                                  ]
                                )
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:number_minor)
                                      op: Equal
                                      rhs: {($ VSub_Number '$2')}
                                    )
                                  ]
                                )
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:number_revision)
                                      op: Equal
                                      rhs: {($ VSub_Number '$3')}
                                    )
                                  ]
                                )
                                (command.Case
                                  to_match: {($ VSub_DollarName '$version_type')}
                                  arms: [
                                    (case_arm
                                      pat_list: [
                                        {(darwin)}
                                        {(freebsd-elf)}
                                        {(linux)}
                                        {(osf)}
                                        {(windows)}
                                        {(none)}
                                      ]
                                      action: [
                                        (C {(func_arith)} {($ VSub_DollarName '$number_major')} 
                                          {(Lit_Other '+')} {($ VSub_DollarName '$number_minor')}
                                        )
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:current)
                                              op: Equal
                                              rhs: {($ VSub_DollarName '$func_arith_result')}
                                            )
                                          ]
                                        )
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:age)
                                              op: Equal
                                              rhs: {($ VSub_DollarName '$number_minor')}
                                            )
                                          ]
                                        )
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:revision)
                                              op: Equal
                                              rhs: {($ VSub_DollarName '$number_revision')}
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                    (case_arm
                                      pat_list: [{(freebsd-aout)} {(qnx)} {(sunos)}]
                                      action: [
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:current)
                                              op: Equal
                                              rhs: {($ VSub_DollarName '$number_major')}
                                            )
                                          ]
                                        )
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:revision)
                                              op: Equal
                                              rhs: {($ VSub_DollarName '$number_minor')}
                                            )
                                          ]
                                        )
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:age)
                                              op: Equal
                                              rhs: {(0)}
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                    (case_arm
                                      pat_list: [{(irix)} {(nonstopux)}]
                                      action: [
                                        (C {(func_arith)} {($ VSub_DollarName '$number_major')} 
                                          {(Lit_Other '+')} {($ VSub_DollarName '$number_minor')}
                                        )
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:current)
                                              op: Equal
                                              rhs: {($ VSub_DollarName '$func_arith_result')}
                                            )
                                          ]
                                        )
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:age)
                                              op: Equal
                                              rhs: {($ VSub_DollarName '$number_minor')}
                                            )
                                          ]
                                        )
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:revision)
                                              op: Equal
                                              rhs: {($ VSub_DollarName '$number_minor')}
                                            )
                                          ]
                                        )
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:lt_irix_increment)
                                              op: Equal
                                              rhs: {(no)}
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                    (case_arm
                                      pat_list: [{(Lit_Star '*')}]
                                      action: [
                                        (C {(func_fatal_configuration)} 
                                          {
                                            (DQ ($ VSub_DollarName '$modename') 
                                              (": unknown library version type '") ($ VSub_DollarName '$version_type') ("'")
                                            )
                                          }
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                            )
                            (case_arm
                              pat_list: [{(no)}]
                              action: [
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:current)
                                      op: Equal
                                      rhs: {($ VSub_Number '$1')}
                                    )
                                  ]
                                )
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:revision)
                                      op: Equal
                                      rhs: {($ VSub_Number '$2')}
                                    )
                                  ]
                                )
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:age)
                                      op: Equal
                                      rhs: {($ VSub_Number '$3')}
                                    )
                                  ]
                                )
                              ]
                            )
                          ]
                        )
                        (command.Case
                          to_match: {($ VSub_DollarName '$current')}
                          arms: [
                            (case_arm
                              pat_list: [
                                {(0)}
                                {(Lit_LBracket '[') (1-9) (Lit_RBracket ']')}
                                {(Lit_LBracket '[') (1-9) (Lit_RBracket ']') (Lit_LBracket '[') (0-9) 
                                  (Lit_RBracket ']')
                                }
                                {(Lit_LBracket '[') (1-9) (Lit_RBracket ']') (Lit_LBracket '[') (0-9) 
                                  (Lit_RBracket ']') (Lit_LBracket '[') (0-9) (Lit_RBracket ']')
                                }
                                {(Lit_LBracket '[') (1-9) (Lit_RBracket ']') (Lit_LBracket '[') (0-9) 
                                  (Lit_RBracket ']') (Lit_LBracket '[') (0-9) (Lit_RBracket ']') (Lit_LBracket '[') (0-9) (Lit_RBracket ']')
                                }
                                {(Lit_LBracket '[') (1-9) (Lit_RBracket ']') (Lit_LBracket '[') (0-9) 
                                  (Lit_RBracket ']') (Lit_LBracket '[') (0-9) (Lit_RBracket ']') (Lit_LBracket '[') (0-9) (Lit_RBracket ']') (Lit_LBracket '[') 
                                  (0-9) (Lit_RBracket ']')
                                }
                              ]
                            )
                            (case_arm
                              pat_list: [{(Lit_Star '*')}]
                              action: [
                                (C {(func_error)} 
                                  {
                                    (DQ ("CURRENT '") ($ VSub_DollarName '$current') 
                                      ("' must be a nonnegative integer")
                                    )
                                  }
                                )
                                (C {(func_fatal_error)} 
                                  {
                                    (DQ ("'") ($ VSub_DollarName '$vinfo') 
                                      ("' is not valid version information")
                                    )
                                  }
                                )
                              ]
                            )
                          ]
                        )
                        (command.Case
                          to_match: {($ VSub_DollarName '$revision')}
                          arms: [
                            (case_arm
                              pat_list: [
                                {(0)}
                                {(Lit_LBracket '[') (1-9) (Lit_RBracket ']')}
                                {(Lit_LBracket '[') (1-9) (Lit_RBracket ']') (Lit_LBracket '[') (0-9) 
                                  (Lit_RBracket ']')
                                }
                                {(Lit_LBracket '[') (1-9) (Lit_RBracket ']') (Lit_LBracket '[') (0-9) 
                                  (Lit_RBracket ']') (Lit_LBracket '[') (0-9) (Lit_RBracket ']')
                                }
                                {(Lit_LBracket '[') (1-9) (Lit_RBracket ']') (Lit_LBracket '[') (0-9) 
                                  (Lit_RBracket ']') (Lit_LBracket '[') (0-9) (Lit_RBracket ']') (Lit_LBracket '[') (0-9) (Lit_RBracket ']')
                                }
                                {(Lit_LBracket '[') (1-9) (Lit_RBracket ']') (Lit_LBracket '[') (0-9) 
                                  (Lit_RBracket ']') (Lit_LBracket '[') (0-9) (Lit_RBracket ']') (Lit_LBracket '[') (0-9) (Lit_RBracket ']') (Lit_LBracket '[') 
                                  (0-9) (Lit_RBracket ']')
                                }
                              ]
                            )
                            (case_arm
                              pat_list: [{(Lit_Star '*')}]
                              action: [
                                (C {(func_error)} 
                                  {
                                    (DQ ("REVISION '") ($ VSub_DollarName '$revision') 
                                      ("' must be a nonnegative integer")
                                    )
                                  }
                                )
                                (C {(func_fatal_error)} 
                                  {
                                    (DQ ("'") ($ VSub_DollarName '$vinfo') 
                                      ("' is not valid version information")
                                    )
                                  }
                                )
                              ]
                            )
                          ]
                        )
                        (command.Case
                          to_match: {($ VSub_DollarName '$age')}
                          arms: [
                            (case_arm
                              pat_list: [
                                {(0)}
                                {(Lit_LBracket '[') (1-9) (Lit_RBracket ']')}
                                {(Lit_LBracket '[') (1-9) (Lit_RBracket ']') (Lit_LBracket '[') (0-9) 
                                  (Lit_RBracket ']')
                                }
                                {(Lit_LBracket '[') (1-9) (Lit_RBracket ']') (Lit_LBracket '[') (0-9) 
                                  (Lit_RBracket ']') (Lit_LBracket '[') (0-9) (Lit_RBracket ']')
                                }
                                {(Lit_LBracket '[') (1-9) (Lit_RBracket ']') (Lit_LBracket '[') (0-9) 
                                  (Lit_RBracket ']') (Lit_LBracket '[') (0-9) (Lit_RBracket ']') (Lit_LBracket '[') (0-9) (Lit_RBracket ']')
                                }
                                {(Lit_LBracket '[') (1-9) (Lit_RBracket ']') (Lit_LBracket '[') (0-9) 
                                  (Lit_RBracket ']') (Lit_LBracket '[') (0-9) (Lit_RBracket ']') (Lit_LBracket '[') (0-9) (Lit_RBracket ']') (Lit_LBracket '[') 
                                  (0-9) (Lit_RBracket ']')
                                }
                              ]
                            )
                            (case_arm
                              pat_list: [{(Lit_Star '*')}]
                              action: [
                                (C {(func_error)} 
                                  {
                                    (DQ ("AGE '") ($ VSub_DollarName '$age') 
                                      ("' must be a nonnegative integer")
                                    )
                                  }
                                )
                                (C {(func_fatal_error)} 
                                  {
                                    (DQ ("'") ($ VSub_DollarName '$vinfo') 
                                      ("' is not valid version information")
                                    )
                                  }
                                )
                              ]
                            )
                          ]
                        )
                        (command.If
                          arms: [
                            (if_arm
                              cond: [
                                (command.Sentence
                                  child: 
                                    (C {(test)} {(DQ ($ VSub_DollarName '$age'))} {(-gt)} 
                                      {(DQ ($ VSub_DollarName '$current'))}
                                    )
                                  terminator: <Op_Semi ';'>
                                )
                              ]
                              action: [
                                (C {(func_error)} 
                                  {
                                    (DQ ("AGE '") ($ VSub_DollarName '$age') 
                                      ("' is greater than the current interface number '") ($ VSub_DollarName '$current') ("'")
                                    )
                                  }
                                )
                                (C {(func_fatal_error)} 
                                  {
                                    (DQ ("'") ($ VSub_DollarName '$vinfo') 
                                      ("' is not valid version information")
                                    )
                                  }
                                )
                              ]
                            )
                          ]
                        )
                        (command.ShAssignment
                          pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:major) op:Equal rhs:(word.Empty))]
                        )
                        (command.ShAssignment
                          pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:versuffix) op:Equal rhs:(word.Empty))]
                        )
                        (command.ShAssignment
                          pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:verstring) op:Equal rhs:(word.Empty))]
                        )
                        (command.Case
                          to_match: {($ VSub_DollarName '$version_type')}
                          arms: [
                            (case_arm pat_list:[{(none)}])
                            (case_arm
                              pat_list: [{(darwin)}]
                              action: [
                                (C {(func_arith)} {($ VSub_DollarName '$current')} {(-)} 
                                  {($ VSub_DollarName '$age')}
                                )
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:major)
                                      op: Equal
                                      rhs: {(.) ($ VSub_DollarName '$func_arith_result')}
                                    )
                                  ]
                                )
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:versuffix)
                                      op: Equal
                                      rhs: 
                                        {($ VSub_DollarName '$major') (.) ($ VSub_DollarName '$age') 
                                          (.) ($ VSub_DollarName '$revision')
                                        }
                                    )
                                  ]
                                )
                                (C {(func_arith)} {($ VSub_DollarName '$current')} {(Lit_Other '+')} 
                                  {(1)}
                                )
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:minor_current)
                                      op: Equal
                                      rhs: {($ VSub_DollarName '$func_arith_result')}
                                    )
                                  ]
                                )
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:xlcverstring)
                                      op: Equal
                                      rhs: 
                                        {
                                          (DQ ($ VSub_DollarName '$wl') ('-compatibility_version ') 
                                            ($ VSub_DollarName '$wl') ($ VSub_DollarName '$minor_current') (' ') ($ VSub_DollarName '$wl') ('-current_version ') 
                                            ($ VSub_DollarName '$wl') ($ VSub_DollarName '$minor_current') (.) ($ VSub_DollarName '$revision')
                                          )
                                        }
                                    )
                                  ]
                                )
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:verstring)
                                      op: Equal
                                      rhs: 
                                        {
                                          (DQ ('-compatibility_version ') 
                                            ($ VSub_DollarName '$minor_current') (' -current_version ') ($ VSub_DollarName '$minor_current') (.) ($ VSub_DollarName '$revision')
                                          )
                                        }
                                    )
                                  ]
                                )
                                (command.Case
                                  to_match: {($ VSub_DollarName '$CC')}
                                  arms: [
                                    (case_arm
                                      pat_list: [{(nagfor) (Lit_Star '*')}]
                                      action: [
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:verstring)
                                              op: Equal
                                              rhs: 
                                                {
                                                  (DQ ($ VSub_DollarName '$wl') 
                                                    ('-compatibility_version ') ($ VSub_DollarName '$wl') ($ VSub_DollarName '$minor_current') (' ') ($ VSub_DollarName '$wl') 
                                                    ('-current_version ') ($ VSub_DollarName '$wl') ($ VSub_DollarName '$minor_current') (.) ($ VSub_DollarName '$revision')
                                                  )
                                                }
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                    (case_arm
                                      pat_list: [{(Lit_Star '*')}]
                                      action: [
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:verstring)
                                              op: Equal
                                              rhs: 
                                                {
                                                  (DQ ('-compatibility_version ') 
                                                    ($ VSub_DollarName '$minor_current') (' -current_version ') ($ VSub_DollarName '$minor_current') (.) ($ VSub_DollarName '$revision')
                                                  )
                                                }
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                            )
                            (case_arm
                              pat_list: [{(freebsd-aout)}]
                              action: [
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:major)
                                      op: Equal
                                      rhs: {(.) ($ VSub_DollarName '$current')}
                                    )
                                  ]
                                )
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:versuffix)
                                      op: Equal
                                      rhs: 
                                        {(.) ($ VSub_DollarName '$current') (.) 
                                          ($ VSub_DollarName '$revision')
                                        }
                                    )
                                  ]
                                )
                              ]
                            )
                            (case_arm
                              pat_list: [{(freebsd-elf)}]
                              action: [
                                (C {(func_arith)} {($ VSub_DollarName '$current')} {(-)} 
                                  {($ VSub_DollarName '$age')}
                                )
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:major)
                                      op: Equal
                                      rhs: {(.) ($ VSub_DollarName '$func_arith_result')}
                                    )
                                  ]
                                )
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:versuffix)
                                      op: Equal
                                      rhs: 
                                        {($ VSub_DollarName '$major') (.) ($ VSub_DollarName '$age') 
                                          (.) ($ VSub_DollarName '$revision')
                                        }
                                    )
                                  ]
                                )
                              ]
                            )
                            (case_arm
                              pat_list: [{(irix)} {(nonstopux)}]
                              action: [
                                (command.If
                                  arms: [
                                    (if_arm
                                      cond: [
                                        (command.Sentence
                                          child: 
                                            (C {(test)} {(no)} {(Lit_Equals '=')} 
                                              {(DQ ($ VSub_DollarName '$lt_irix_increment'))}
                                            )
                                          terminator: <Op_Semi ';'>
                                        )
                                      ]
                                      action: [
                                        (C {(func_arith)} {($ VSub_DollarName '$current')} {(-)} 
                                          {($ VSub_DollarName '$age')}
                                        )
                                      ]
                                    )
                                  ]
                                  else_action: [
                                    (C {(func_arith)} {($ VSub_DollarName '$current')} {(-)} 
                                      {($ VSub_DollarName '$age')} {(Lit_Other '+')} {(1)}
                                    )
                                  ]
                                )
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:major)
                                      op: Equal
                                      rhs: {($ VSub_DollarName '$func_arith_result')}
                                    )
                                  ]
                                )
                                (command.Case
                                  to_match: {($ VSub_DollarName '$version_type')}
                                  arms: [
                                    (case_arm
                                      pat_list: [{(nonstopux)}]
                                      action: [
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:verstring_prefix)
                                              op: Equal
                                              rhs: {(nonstopux)}
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                    (case_arm
                                      pat_list: [{(Lit_Star '*')}]
                                      action: [
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:verstring_prefix)
                                              op: Equal
                                              rhs: {(sgi)}
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                  ]
                                )
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:verstring)
                                      op: Equal
                                      rhs: 
                                        {($ VSub_DollarName '$verstring_prefix') 
                                          ($ VSub_DollarName '$major') (.) ($ VSub_DollarName '$revision')
                                        }
                                    )
                                  ]
                                )
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:loop)
                                      op: Equal
                                      rhs: {($ VSub_DollarName '$revision')}
                                    )
                                  ]
                                )
                                (command.WhileUntil
                                  keyword: <KW_While while>
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (C {(test)} {(0)} {(-ne)} {(DQ ($ VSub_DollarName '$loop'))})
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  body: 
                                    (command.DoGroup
                                      children: [
                                        (C {(func_arith)} {($ VSub_DollarName '$revision')} {(-)} 
                                          {($ VSub_DollarName '$loop')}
                                        )
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:iface)
                                              op: Equal
                                              rhs: {($ VSub_DollarName '$func_arith_result')}
                                            )
                                          ]
                                        )
                                        (C {(func_arith)} {($ VSub_DollarName '$loop')} {(-)} {(1)})
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:loop)
                                              op: Equal
                                              rhs: {($ VSub_DollarName '$func_arith_result')}
                                            )
                                          ]
                                        )
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:verstring)
                                              op: Equal
                                              rhs: 
                                                {($ VSub_DollarName '$verstring_prefix') 
                                                  ($ VSub_DollarName '$major') (.) ($ VSub_DollarName '$iface') (Lit_Other ':') ($ VSub_DollarName '$verstring')
                                                }
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                )
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:major)
                                      op: Equal
                                      rhs: {(.) ($ VSub_DollarName '$major')}
                                    )
                                  ]
                                )
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:versuffix)
                                      op: Equal
                                      rhs: 
                                        {($ VSub_DollarName '$major') (.) 
                                          ($ VSub_DollarName '$revision')
                                        }
                                    )
                                  ]
                                )
                              ]
                            )
                            (case_arm
                              pat_list: [{(linux)}]
                              action: [
                                (C {(func_arith)} {($ VSub_DollarName '$current')} {(-)} 
                                  {($ VSub_DollarName '$age')}
                                )
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:major)
                                      op: Equal
                                      rhs: {(.) ($ VSub_DollarName '$func_arith_result')}
                                    )
                                  ]
                                )
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:versuffix)
                                      op: Equal
                                      rhs: 
                                        {($ VSub_DollarName '$major') (.) ($ VSub_DollarName '$age') 
                                          (.) ($ VSub_DollarName '$revision')
                                        }
                                    )
                                  ]
                                )
                              ]
                            )
                            (case_arm
                              pat_list: [{(osf)}]
                              action: [
                                (C {(func_arith)} {($ VSub_DollarName '$current')} {(-)} 
                                  {($ VSub_DollarName '$age')}
                                )
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:major)
                                      op: Equal
                                      rhs: {(.) ($ VSub_DollarName '$func_arith_result')}
                                    )
                                  ]
                                )
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:versuffix)
                                      op: Equal
                                      rhs: 
                                        {(.) ($ VSub_DollarName '$current') (.) 
                                          ($ VSub_DollarName '$age') (.) ($ VSub_DollarName '$revision')
                                        }
                                    )
                                  ]
                                )
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:verstring)
                                      op: Equal
                                      rhs: 
                                        {($ VSub_DollarName '$current') (.) ($ VSub_DollarName '$age') 
                                          (.) ($ VSub_DollarName '$revision')
                                        }
                                    )
                                  ]
                                )
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:loop)
                                      op: Equal
                                      rhs: {($ VSub_DollarName '$age')}
                                    )
                                  ]
                                )
                                (command.WhileUntil
                                  keyword: <KW_While while>
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (C {(test)} {(0)} {(-ne)} {(DQ ($ VSub_DollarName '$loop'))})
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  body: 
                                    (command.DoGroup
                                      children: [
                                        (C {(func_arith)} {($ VSub_DollarName '$current')} {(-)} 
                                          {($ VSub_DollarName '$loop')}
                                        )
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:iface)
                                              op: Equal
                                              rhs: {($ VSub_DollarName '$func_arith_result')}
                                            )
                                          ]
                                        )
                                        (C {(func_arith)} {($ VSub_DollarName '$loop')} {(-)} {(1)})
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:loop)
                                              op: Equal
                                              rhs: {($ VSub_DollarName '$func_arith_result')}
                                            )
                                          ]
                                        )
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:verstring)
                                              op: Equal
                                              rhs: 
                                                {($ VSub_DollarName '$verstring') (Lit_Other ':') 
                                                  ($ VSub_DollarName '$iface') (.0)
                                                }
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                )
                                (C {(func_append)} {(verstring)} 
                                  {(DQ (':') ($ VSub_DollarName '$current') (.0))}
                                )
                              ]
                            )
                            (case_arm
                              pat_list: [{(qnx)}]
                              action: [
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:major)
                                      op: Equal
                                      rhs: {(.) ($ VSub_DollarName '$current')}
                                    )
                                  ]
                                )
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:versuffix)
                                      op: Equal
                                      rhs: {(.) ($ VSub_DollarName '$current')}
                                    )
                                  ]
                                )
                              ]
                            )
                            (case_arm
                              pat_list: [{(sco)}]
                              action: [
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:major)
                                      op: Equal
                                      rhs: {(.) ($ VSub_DollarName '$current')}
                                    )
                                  ]
                                )
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:versuffix)
                                      op: Equal
                                      rhs: {(.) ($ VSub_DollarName '$current')}
                                    )
                                  ]
                                )
                              ]
                            )
                            (case_arm
                              pat_list: [{(sunos)}]
                              action: [
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:major)
                                      op: Equal
                                      rhs: {(.) ($ VSub_DollarName '$current')}
                                    )
                                  ]
                                )
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:versuffix)
                                      op: Equal
                                      rhs: 
                                        {(.) ($ VSub_DollarName '$current') (.) 
                                          ($ VSub_DollarName '$revision')
                                        }
                                    )
                                  ]
                                )
                              ]
                            )
                            (case_arm
                              pat_list: [{(windows)}]
                              action: [
                                (C {(func_arith)} {($ VSub_DollarName '$current')} {(-)} 
                                  {($ VSub_DollarName '$age')}
                                )
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:major)
                                      op: Equal
                                      rhs: {($ VSub_DollarName '$func_arith_result')}
                                    )
                                  ]
                                )
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:versuffix)
                                      op: Equal
                                      rhs: {(-) ($ VSub_DollarName '$major')}
                                    )
                                  ]
                                )
                              ]
                            )
                            (case_arm
                              pat_list: [{(Lit_Star '*')}]
                              action: [
                                (C {(func_fatal_configuration)} 
                                  {
                                    (DQ ("unknown library version type '") 
                                      ($ VSub_DollarName '$version_type') ("'")
                                    )
                                  }
                                )
                              ]
                            )
                          ]
                        )
                        (command.If
                          arms: [
                            (if_arm
                              cond: [
                                (command.Sentence
                                  child: 
                                    (command.AndOr
                                      ops: [Op_DAmp]
                                      children: [
                                        (C {(test)} {(-z)} {(DQ ($ VSub_DollarName '$vinfo'))})
                                        (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$release'))})
                                      ]
                                    )
                                  terminator: <Op_Semi ';'>
                                )
                              ]
                              action: [
                                (command.ShAssignment
                                  pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:major) op:Equal rhs:(word.Empty))]
                                )
                                (command.Case
                                  to_match: {($ VSub_DollarName '$version_type')}
                                  arms: [
                                    (case_arm
                                      pat_list: [{(darwin)}]
                                      action: [
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:verstring)
                                              op: Equal
                                              rhs: (word.Empty)
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                    (case_arm
                                      pat_list: [{(Lit_Star '*')}]
                                      action: [
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:verstring)
                                              op: Equal
                                              rhs: {(0.0)}
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                  ]
                                )
                                (command.If
                                  arms: [
                                    (if_arm
                                      cond: [
                                        (command.Sentence
                                          child: 
                                            (C {(test)} {(no)} {(Lit_Equals '=')} 
                                              {(DQ ($ VSub_DollarName '$need_version'))}
                                            )
                                          terminator: <Op_Semi ';'>
                                        )
                                      ]
                                      action: [
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:versuffix)
                                              op: Equal
                                              rhs: (word.Empty)
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                  ]
                                  else_action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:versuffix)
                                          op: Equal
                                          rhs: {(.0.0)}
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                            )
                          ]
                        )
                        (command.If
                          arms: [
                            (if_arm
                              cond: [
                                (command.Sentence
                                  child: 
                                    (C {(test)} {(yes) (Lit_Comma ',') (no)} {(Lit_Equals '=')} 
                                      {
                                        (DQ ($ VSub_DollarName '$avoid_version') (',') 
                                          ($ VSub_DollarName '$need_version')
                                        )
                                      }
                                    )
                                  terminator: <Op_Semi ';'>
                                )
                              ]
                              action: [
                                (command.ShAssignment
                                  pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:major) op:Equal rhs:(word.Empty))]
                                )
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:versuffix)
                                      op: Equal
                                      rhs: (word.Empty)
                                    )
                                  ]
                                )
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:verstring)
                                      op: Equal
                                      rhs: (word.Empty)
                                    )
                                  ]
                                )
                              ]
                            )
                          ]
                        )
                        (command.If
                          arms: [
                            (if_arm
                              cond: [
                                (command.Sentence
                                  child: 
                                    (C {(test)} {(yes)} {(Lit_Equals '=')} 
                                      {(DQ ($ VSub_DollarName '$allow_undefined'))}
                                    )
                                  terminator: <Op_Semi ';'>
                                )
                              ]
                              action: [
                                (command.If
                                  arms: [
                                    (if_arm
                                      cond: [
                                        (command.Sentence
                                          child: 
                                            (C {(test)} {(unsupported)} {(Lit_Equals '=')} 
                                              {(DQ ($ VSub_DollarName '$allow_undefined_flag'))}
                                            )
                                          terminator: <Op_Semi ';'>
                                        )
                                      ]
                                      action: [
                                        (command.If
                                          arms: [
                                            (if_arm
                                              cond: [
                                                (command.Sentence
                                                  child: 
                                                    (C {(test)} {(yes)} {(Lit_Equals '=')} 
                                                      {(DQ ($ VSub_DollarName '$build_old_libs'))}
                                                    )
                                                  terminator: <Op_Semi ';'>
                                                )
                                              ]
                                              action: [
                                                (C {(func_warning)} 
                                                  {
                                                    (DQ ('undefined symbols not allowed in ') 
                                                      ($ VSub_DollarName '$host') (' shared libraries; building static only')
                                                    )
                                                  }
                                                )
                                                (command.ShAssignment
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (sh_lhs_expr.Name name:build_libtool_libs)
                                                      op: Equal
                                                      rhs: {(no)}
                                                    )
                                                  ]
                                                )
                                              ]
                                            )
                                          ]
                                          else_action: [
                                            (C {(func_fatal_error)} 
                                              {
                                                (DQ ("can't build ") ($ VSub_DollarName '$host') 
                                                  (
' shared library unless -no-undefined is specified'
                                                  )
                                                )
                                              }
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                            )
                          ]
                          else_action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:allow_undefined_flag)
                                  op: Equal
                                  rhs: {($ VSub_DollarName '$no_undefined_flag')}
                                )
                              ]
                            )
                          ]
                        )
                      ]
                    )
                    (C {(func_generate_dlsyms)} {(DQ ($ VSub_DollarName '$libname'))} 
                      {(DQ ($ VSub_DollarName '$libname'))} {(Lit_Other ':')}
                    )
                    (C {(func_append)} {(libobjs)} {(DQ (' ') ($ VSub_DollarName '$symfileobj'))})
                    (command.AndOr
                      ops: [Op_DAmp]
                      children: [
                        (C {(test)} {(DQ (' '))} {(Lit_Equals '=')} {(DQ ($ VSub_DollarName '$libobjs'))})
                        (command.ShAssignment
                          pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:libobjs) op:Equal rhs:(word.Empty))]
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: 
                                (C {(test)} {(relink)} {(KW_Bang '!') (Lit_Equals '=')} 
                                  {(DQ ($ VSub_DollarName '$opt_mode'))}
                                )
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [
                            (command.ShAssignment
                              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:removelist) op:Equal rhs:(word.Empty))]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:tempremovelist)
                                  op: Equal
                                  rhs: 
                                    {
                                      (command_sub
                                        left_token: <Left_Backtick '`'>
                                        command_list: 
                                          (command.CommandList
                                            children: [
                                              (C {($ VSub_DollarName '$ECHO')} 
                                                {(DQ ($ VSub_DollarName '$output_objdir') ('/*'))}
                                              )
                                            ]
                                          )
                                      )
                                    }
                                )
                              ]
                            )
                            (command.ForEach
                              iter_name: p
                              iter_words: [{($ VSub_DollarName '$tempremovelist')}]
                              do_arg_iter: F
                              body: 
                                (command.DoGroup
                                  children: [
                                    (command.Case
                                      to_match: {($ VSub_DollarName '$p')}
                                      arms: [
                                        (case_arm
                                          pat_list: [
                                            {(Lit_Star '*') (.) ($ VSub_DollarName '$objext')}
                                            {(Lit_Star '*') (.gcno)}
                                          ]
                                        )
                                        (case_arm
                                          pat_list: [
                                            {($ VSub_DollarName '$output_objdir') (/) 
                                              ($ VSub_DollarName '$outputname')
                                            }
                                            {($ VSub_DollarName '$output_objdir') (/) 
                                              ($ VSub_DollarName '$libname') (.) (Lit_Star '*')
                                            }
                                            {($ VSub_DollarName '$output_objdir') (/) 
                                              ($ VSub_DollarName '$libname') ($ VSub_DollarName '$release') (.) (Lit_Star '*')
                                            }
                                          ]
                                          action: [
                                            (command.If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (command.Sentence
                                                      child: 
                                                        (C {(test)} {(-n)} 
                                                          {
                                                            (DQ 
                                                              ($ VSub_DollarName 
'$precious_files_regex'
                                                              )
                                                            )
                                                          }
                                                        )
                                                      terminator: <Op_Semi ';'>
                                                    )
                                                  ]
                                                  action: [
                                                    (command.If
                                                      arms: [
                                                        (if_arm
                                                          cond: [
                                                            (command.Pipeline
                                                              children: [
                                                                (C {($ VSub_DollarName '$ECHO')} 
                                                                  {(DQ ($ VSub_DollarName '$p'))}
                                                                )
                                                                (command.Simple
                                                                  words: [
                                                                    {($ VSub_DollarName '$EGREP')}
                                                                    {(-e)}
                                                                    {
                                                                      (DQ 
                                                                        ($ VSub_DollarName 
'$precious_files_regex'
                                                                        )
                                                                      )
                                                                    }
                                                                  ]
                                                                  redirects: [
                                                                    (redir.Redir
                                                                      op: <Redir_Great '>'>
                                                                      fd: 16777215
                                                                      arg_word: {(/dev/null)}
                                                                    )
                                                                    (redir.Redir
                                                                      op: <Redir_GreatAnd '2>&'>
                                                                      fd: 2
                                                                      arg_word: {(1)}
                                                                    )
                                                                  ]
                                                                )
                                                              ]
                                                              negated: F
                                                            )
                                                          ]
                                                          action: [
                                                            (command.ControlFlow
                                                              token: <ControlFlow_Continue continue>
                                                            )
                                                          ]
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                )
                                              ]
                                            )
                                            (C {(func_append)} {(removelist)} 
                                              {(DQ (' ') ($ VSub_DollarName '$p'))}
                                            )
                                          ]
                                        )
                                        (case_arm
                                          pat_list: [{(Lit_Star '*')}]
                                        )
                                      ]
                                    )
                                  ]
                                )
                            )
                            (command.AndOr
                              ops: [Op_DAmp]
                              children: [
                                (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$removelist'))})
                                (C {(func_show_eval)} 
                                  {
                                    (DQ (${ VSub_Name RM) ('r ') 
                                      (word_part.EscapedLiteral
                                        token: <Lit_EscapedChar '\\$'>
                                      ) (removelist)
                                    )
                                  }
                                )
                              ]
                            )
                          ]
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: 
                                (command.AndOr
                                  ops: [Op_DAmp]
                                  children: [
                                    (C {(test)} {(yes)} {(Lit_Equals '=')} 
                                      {(DQ ($ VSub_DollarName '$build_old_libs'))}
                                    )
                                    (C {(test)} {(convenience)} {(KW_Bang '!') (Lit_Equals '=')} 
                                      {(DQ ($ VSub_DollarName '$build_libtool_libs'))}
                                    )
                                  ]
                                )
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [
                            (C {(func_append)} {(oldlibs)} 
                              {
                                (DQ (' ') ($ VSub_DollarName '$output_objdir') (/) 
                                  ($ VSub_DollarName '$libname') (.) ($ VSub_DollarName '$libext')
                                )
                              }
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:oldobjs)
                                  op: Equal
                                  rhs: 
                                    {(DQ ($ VSub_DollarName '$objs') (' ')) 
                                      (command_sub
                                        left_token: <Left_Backtick '`'>
                                        command_list: 
                                          (command.CommandList
                                            children: [
                                              (command.Pipeline
                                                children: [
                                                  (C {($ VSub_DollarName '$ECHO')} 
                                                    {(DQ ($ VSub_DollarName '$libobjs'))}
                                                  )
                                                  (C {($ VSub_DollarName '$SP2NL')})
                                                  (C {($ VSub_DollarName '$SED')} 
                                                    {
                                                      (DQ (/) (Lit_Other '\\') (.) 
                                                        ($ VSub_DollarName '$libext') (Lit_Other '$') ('/d; ') ($ VSub_DollarName '$lo2o')
                                                      )
                                                    }
                                                  )
                                                  (C {($ VSub_DollarName '$NL2SP')})
                                                ]
                                                negated: F
                                              )
                                            ]
                                          )
                                      )
                                    }
                                )
                              ]
                            )
                          ]
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$xrpath'))})
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [
                            (command.ShAssignment
                              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:temp_xrpath) op:Equal rhs:(word.Empty))]
                            )
                            (command.ForEach
                              iter_name: libdir
                              iter_words: [{($ VSub_DollarName '$xrpath')}]
                              do_arg_iter: F
                              body: 
                                (command.DoGroup
                                  children: [
                                    (C {(func_replace_sysroot)} {(DQ ($ VSub_DollarName '$libdir'))})
                                    (C {(func_append)} {(temp_xrpath)} 
                                      {
                                        (DQ (' -R') ($ VSub_DollarName '$func_replace_sysroot_result'))
                                      }
                                    )
                                    (command.Case
                                      to_match: {(DQ ($ VSub_DollarName '$finalize_rpath') (' '))}
                                      arms: [
                                        (case_arm
                                          pat_list: [
                                            {(Lit_Star '*') 
                                              (DQ (' ') ($ VSub_DollarName '$libdir') (' ')) (Lit_Star '*')
                                            }
                                          ]
                                        )
                                        (case_arm
                                          pat_list: [{(Lit_Star '*')}]
                                          action: [
                                            (C {(func_append)} {(finalize_rpath)} 
                                              {(DQ (' ') ($ VSub_DollarName '$libdir'))}
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                  ]
                                )
                            )
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (command.AndOr
                                          ops: [Op_DPipe]
                                          children: [
                                            (C {(test)} {(yes)} {(KW_Bang '!') (Lit_Equals '=')} 
                                              {(DQ ($ VSub_DollarName '$hardcode_into_libs'))}
                                            )
                                            (C {(test)} {(yes)} {(Lit_Equals '=')} 
                                              {(DQ ($ VSub_DollarName '$build_old_libs'))}
                                            )
                                          ]
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:dependency_libs)
                                          op: Equal
                                          rhs: 
                                            {
                                              (DQ ($ VSub_DollarName '$temp_xrpath') (' ') 
                                                ($ VSub_DollarName '$dependency_libs')
                                              )
                                            }
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                            )
                          ]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:old_dlfiles)
                          op: Equal
                          rhs: {($ VSub_DollarName '$dlfiles')}
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:dlfiles) op:Equal rhs:(word.Empty))]
                    )
                    (command.ForEach
                      iter_name: lib
                      iter_words: [{($ VSub_DollarName '$old_dlfiles')}]
                      do_arg_iter: F
                      body: 
                        (command.DoGroup
                          children: [
                            (command.Case
                              to_match: 
                                {
                                  (DQ (' ') ($ VSub_DollarName '$dlprefiles') (' ') 
                                    ($ VSub_DollarName '$dlfiles') (' ')
                                  )
                                }
                              arms: [
                                (case_arm
                                  pat_list: [
                                    {(Lit_Star '*') (DQ (' ') ($ VSub_DollarName '$lib') (' ')) 
                                      (Lit_Star '*')
                                    }
                                  ]
                                )
                                (case_arm
                                  pat_list: [{(Lit_Star '*')}]
                                  action: [
                                    (C {(func_append)} {(dlfiles)} 
                                      {(DQ (' ') ($ VSub_DollarName '$lib'))}
                                    )
                                  ]
                                )
                              ]
                            )
                          ]
                        )
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:old_dlprefiles)
                          op: Equal
                          rhs: {($ VSub_DollarName '$dlprefiles')}
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:dlprefiles) op:Equal rhs:(word.Empty))]
                    )
                    (command.ForEach
                      iter_name: lib
                      iter_words: [{($ VSub_DollarName '$old_dlprefiles')}]
                      do_arg_iter: F
                      body: 
                        (command.DoGroup
                          children: [
                            (command.Case
                              to_match: {(DQ ($ VSub_DollarName '$dlprefiles') (' '))}
                              arms: [
                                (case_arm
                                  pat_list: [
                                    {(Lit_Star '*') (DQ (' ') ($ VSub_DollarName '$lib') (' ')) 
                                      (Lit_Star '*')
                                    }
                                  ]
                                )
                                (case_arm
                                  pat_list: [{(Lit_Star '*')}]
                                  action: [
                                    (C {(func_append)} {(dlprefiles)} 
                                      {(DQ (' ') ($ VSub_DollarName '$lib'))}
                                    )
                                  ]
                                )
                              ]
                            )
                          ]
                        )
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: 
                                (C {(test)} {(yes)} {(Lit_Equals '=')} 
                                  {(DQ ($ VSub_DollarName '$build_libtool_libs'))}
                                )
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$rpath'))})
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (command.Case
                                      to_match: {($ VSub_DollarName '$host')}
                                      arms: [
                                        (case_arm
                                          pat_list: [
                                            {(Lit_Star '*') (-) (Lit_Star '*') (-cygwin) (Lit_Star '*')}
                                            {(Lit_Star '*') (-) (Lit_Star '*') (-mingw) (Lit_Star '*')}
                                            {(Lit_Star '*') (-) (Lit_Star '*') (-pw32) (Lit_Star '*')}
                                            {(Lit_Star '*') (-) (Lit_Star '*') (-os2) (Lit_Star '*')}
                                            {(Lit_Star '*') (-) (Lit_Star '*') (-beos) (Lit_Star '*')}
                                            {(Lit_Star '*') (-cegcc) (Lit_Star '*')}
                                            {(Lit_Star '*') (-) (Lit_Star '*') (-haiku) (Lit_Star '*')}
                                          ]
                                        )
                                        (case_arm
                                          pat_list: [
                                            {(Lit_Star '*') (-) (Lit_Star '*') (-rhapsody) 
                                              (Lit_Star '*')
                                            }
                                            {(Lit_Star '*') (-) (Lit_Star '*') (-darwin1.) 
                                              (Lit_LBracket '[') (012) (Lit_RBracket ']')
                                            }
                                          ]
                                          action: [
                                            (C {(func_append)} {(deplibs)} {(DQ (' System.ltframework'))})
                                          ]
                                        )
                                        (case_arm
                                          pat_list: [
                                            {(Lit_Star '*') (-) (Lit_Star '*') (-netbsd) (Lit_Star '*')}
                                          ]
                                        )
                                        (case_arm
                                          pat_list: [
                                            {(Lit_Star '*') (-) (Lit_Star '*') (-openbsd) (Lit_Star '*')}
                                            {(Lit_Star '*') (-) (Lit_Star '*') (-freebsd) (Lit_Star '*')}
                                            {(Lit_Star '*') (-) (Lit_Star '*') (-dragonfly) 
                                              (Lit_Star '*')
                                            }
                                          ]
                                        )
                                        (case_arm
                                          pat_list: [
                                            {(Lit_Star '*') (-) (Lit_Star '*') (-sco3.2v5) 
                                              (Lit_Star '*')
                                            }
                                            {(Lit_Star '*') (-) (Lit_Star '*') (-sco5v6) (Lit_Star '*')}
                                          ]
                                        )
                                        (case_arm
                                          pat_list: [
                                            {(Lit_Star '*') (-) (Lit_Star '*') (-sysv4.2uw2) 
                                              (Lit_Star '*')
                                            }
                                            {(Lit_Star '*') (-) (Lit_Star '*') (-sysv5) (Lit_Star '*')}
                                            {(Lit_Star '*') (-) (Lit_Star '*') (-unixware) 
                                              (Lit_Star '*')
                                            }
                                            {(Lit_Star '*') (-) (Lit_Star '*') (-OpenUNIX) 
                                              (Lit_Star '*')
                                            }
                                          ]
                                        )
                                        (case_arm
                                          pat_list: [{(Lit_Star '*')}]
                                          action: [
                                            (command.If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (command.Sentence
                                                      child: 
                                                        (C {(test)} {(yes)} {(Lit_Equals '=')} 
                                                          {
                                                            (DQ 
                                                              ($ VSub_DollarName 
'$build_libtool_need_lc'
                                                              )
                                                            )
                                                          }
                                                        )
                                                      terminator: <Op_Semi ';'>
                                                    )
                                                  ]
                                                  action: [
                                                    (C {(func_append)} {(deplibs)} {(DQ (' -lc'))})
                                                  ]
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:name_save)
                                  op: Equal
                                  rhs: {($ VSub_DollarName '$name')}
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:libname_save)
                                  op: Equal
                                  rhs: {($ VSub_DollarName '$libname')}
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:release_save)
                                  op: Equal
                                  rhs: {($ VSub_DollarName '$release')}
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:versuffix_save)
                                  op: Equal
                                  rhs: {($ VSub_DollarName '$versuffix')}
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:major_save)
                                  op: Equal
                                  rhs: {($ VSub_DollarName '$major')}
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:release) op:Equal rhs:(word.Empty))]
                            )
                            (command.ShAssignment
                              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:versuffix) op:Equal rhs:(word.Empty))]
                            )
                            (command.ShAssignment
                              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:major) op:Equal rhs:(word.Empty))]
                            )
                            (command.ShAssignment
                              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:newdeplibs) op:Equal rhs:(word.Empty))]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:droppeddeps)
                                  op: Equal
                                  rhs: {(no)}
                                )
                              ]
                            )
                            (command.Case
                              to_match: {($ VSub_DollarName '$deplibs_check_method')}
                              arms: [
                                (case_arm
                                  pat_list: [{(pass_all)}]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:newdeplibs)
                                          op: Equal
                                          rhs: {($ VSub_DollarName '$deplibs')}
                                        )
                                      ]
                                    )
                                  ]
                                )
                                (case_arm
                                  pat_list: [{(test_compile)}]
                                  action: [
                                    (command.AndOr
                                      ops: [Op_DPipe]
                                      children: [
                                        (C {($ VSub_DollarName '$opt_dry_run')})
                                        (C {($ VSub_DollarName '$RM')} {(conftest.c)})
                                      ]
                                    )
                                    (command.Simple
                                      words: [{(cat)}]
                                      redirects: [
                                        (redir.Redir
                                          op: <Redir_Great '>'>
                                          fd: 16777215
                                          arg_word: {(conftest.c)}
                                        )
                                        (redir.HereDoc
                                          op: <Redir_DLess '<<'>
                                          fd: 16777215
                                          here_begin: {(EOF)}
                                          here_end_span_id: 47227
                                          stdin_parts: [('\t  int main() { return 0; }\n')]
                                        )
                                      ]
                                    )
                                    (command.AndOr
                                      ops: [Op_DPipe]
                                      children: [
                                        (C {($ VSub_DollarName '$opt_dry_run')})
                                        (C {($ VSub_DollarName '$RM')} {(conftest)})
                                      ]
                                    )
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (command.Sentence
                                              child: 
                                                (C {($ VSub_DollarName '$LTCC')} 
                                                  {($ VSub_DollarName '$LTCFLAGS')} {(-o)} {(conftest)} {(conftest.c)} {($ VSub_DollarName '$deplibs')}
                                                )
                                              terminator: <Op_Semi ';'>
                                            )
                                          ]
                                          action: [
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:ldd_output)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (command_sub
                                                        left_token: <Left_Backtick '`'>
                                                        command_list: 
                                                          (command.CommandList
                                                            children: [(C {(ldd)} {(conftest)})]
                                                          )
                                                      )
                                                    }
                                                )
                                              ]
                                            )
                                            (command.ForEach
                                              iter_name: i
                                              iter_words: [{($ VSub_DollarName '$deplibs')}]
                                              do_arg_iter: F
                                              body: 
                                                (command.DoGroup
                                                  children: [
                                                    (command.Case
                                                      to_match: {($ VSub_DollarName '$i')}
                                                      arms: [
                                                        (case_arm
                                                          pat_list: [{(-l) (Lit_Star '*')}]
                                                          action: [
                                                            (C {(func_stripname)} {(-l)} {(SQ )} 
                                                              {(DQ ($ VSub_DollarName '$i'))}
                                                            )
                                                            (command.ShAssignment
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: (sh_lhs_expr.Name name:name)
                                                                  op: Equal
                                                                  rhs: 
                                                                    {
                                                                      ($ VSub_DollarName 
'$func_stripname_result'
                                                                      )
                                                                    }
                                                                )
                                                              ]
                                                            )
                                                            (command.If
                                                              arms: [
                                                                (if_arm
                                                                  cond: [
                                                                    (command.Sentence
                                                                      child: 
                                                                        (C {(test)} {(yes)} 
                                                                          {(Lit_Equals '=')} {(DQ ($ VSub_DollarName '$allow_libtool_libs_with_static_runtimes'))}
                                                                        )
                                                                      terminator: <Op_Semi ';'>
                                                                    )
                                                                  ]
                                                                  action: [
                                                                    (command.Case
                                                                      to_match: 
                                                                        {
                                                                          (DQ (' ') 
                                                                            ($ VSub_DollarName 
'$predeps'
                                                                            ) (' ') ($ VSub_DollarName '$postdeps') (' ')
                                                                          )
                                                                        }
                                                                      arms: [
                                                                        (case_arm
                                                                          pat_list: [
                                                                            {(Lit_Star '*') 
                                                                              (DQ (' ') 
                                                                                ($ VSub_DollarName 
'$i'
                                                                                ) (' ')
                                                                              ) (Lit_Star '*')
                                                                            }
                                                                          ]
                                                                          action: [
                                                                            (C {(func_append)} 
                                                                              {(newdeplibs)} {(DQ (' ') ($ VSub_DollarName '$i'))}
                                                                            )
                                                                            (command.ShAssignment
                                                                              pairs: [
                                                                                (assign_pair
                                                                                  lhs: 
                                                                                    (sh_lhs_expr.Name
                                                                                      name: i
                                                                                    )
                                                                                  op: Equal
                                                                                  rhs: (word.Empty)
                                                                                )
                                                                              ]
                                                                            )
                                                                          ]
                                                                        )
                                                                      ]
                                                                    )
                                                                  ]
                                                                )
                                                              ]
                                                            )
                                                            (command.If
                                                              arms: [
                                                                (if_arm
                                                                  cond: [
                                                                    (command.Sentence
                                                                      child: 
                                                                        (C {(test)} {(-n)} 
                                                                          {
                                                                            (DQ 
                                                                              ($ VSub_DollarName '$i')
                                                                            )
                                                                          }
                                                                        )
                                                                      terminator: <Op_Semi ';'>
                                                                    )
                                                                  ]
                                                                  action: [
                                                                    (command.ShAssignment
                                                                      pairs: [
                                                                        (assign_pair
                                                                          lhs: 
                                                                            (sh_lhs_expr.Name
                                                                              name: libname
                                                                            )
                                                                          op: Equal
                                                                          rhs: 
                                                                            {
                                                                              (command_sub
                                                                                left_token: 
                                                                                  <Left_Backtick '`'>
                                                                                command_list: 
                                                                                  (command.CommandList
                                                                                    children: [
                                                                                      (C {(eval)} 
                                                                                        {
                                                                                          (DQ 
                                                                                            (word_part.EscapedLiteral
                                                                                              token: 
                                                                                                <
Lit_EscapedChar '\\$'
                                                                                                >
                                                                                            ) ('ECHO ')
                                                                                          ) ($ VSub_DollarName '$libname_spec') (DQ )
                                                                                        }
                                                                                      )
                                                                                    ]
                                                                                  )
                                                                              )
                                                                            }
                                                                        )
                                                                      ]
                                                                    )
                                                                    (command.ShAssignment
                                                                      pairs: [
                                                                        (assign_pair
                                                                          lhs: 
                                                                            (sh_lhs_expr.Name
                                                                              name: deplib_matches
                                                                            )
                                                                          op: Equal
                                                                          rhs: 
                                                                            {
                                                                              (command_sub
                                                                                left_token: 
                                                                                  <Left_Backtick '`'>
                                                                                command_list: 
                                                                                  (command.CommandList
                                                                                    children: [
                                                                                      (C {(eval)} 
                                                                                        {
                                                                                          (DQ 
                                                                                            (word_part.EscapedLiteral
                                                                                              token: 
                                                                                                <
Lit_EscapedChar '\\$'
                                                                                                >
                                                                                            ) ('ECHO ')
                                                                                          ) ($ VSub_DollarName '$library_names_spec') (DQ )
                                                                                        }
                                                                                      )
                                                                                    ]
                                                                                  )
                                                                              )
                                                                            }
                                                                        )
                                                                      ]
                                                                    )
                                                                    (command.Sentence
                                                                      child: 
                                                                        (C {(KW_Set set)} {(dummy)} 
                                                                          {
                                                                            ($ VSub_DollarName 
'$deplib_matches'
                                                                            )
                                                                          }
                                                                        )
                                                                      terminator: <Op_Semi ';'>
                                                                    )
                                                                    (C {(shift)})
                                                                    (command.ShAssignment
                                                                      pairs: [
                                                                        (assign_pair
                                                                          lhs: 
                                                                            (sh_lhs_expr.Name
                                                                              name: deplib_match
                                                                            )
                                                                          op: Equal
                                                                          rhs: {($ VSub_Number '$1')}
                                                                        )
                                                                      ]
                                                                    )
                                                                    (command.If
                                                                      arms: [
                                                                        (if_arm
                                                                          cond: [
                                                                            (command.Sentence
                                                                              child: 
                                                                                (C {(test)} 
                                                                                  {
                                                                                    (command_sub
                                                                                      left_token: 
                                                                                        <
Left_Backtick '`'
                                                                                        >
                                                                                      command_list: 
                                                                                        (command.CommandList
                                                                                          children: [
                                                                                            (C 
                                                                                              {
                                                                                                (
expr
                                                                                                )
                                                                                              } {(DQ ($ VSub_DollarName '$ldd_output'))} {(Lit_Other ':')} 
                                                                                              {
                                                                                                (DQ 
                                                                                                  (
'.*'
                                                                                                  ) ($ VSub_DollarName '$deplib_match')
                                                                                                )
                                                                                              }
                                                                                            )
                                                                                          ]
                                                                                        )
                                                                                    )
                                                                                  } {(-ne)} {(0)}
                                                                                )
                                                                              terminator: 
                                                                                <Op_Semi ';'>
                                                                            )
                                                                          ]
                                                                          action: [
                                                                            (C {(func_append)} 
                                                                              {(newdeplibs)} {(DQ (' ') ($ VSub_DollarName '$i'))}
                                                                            )
                                                                          ]
                                                                        )
                                                                      ]
                                                                      else_action: [
                                                                        (command.ShAssignment
                                                                          pairs: [
                                                                            (assign_pair
                                                                              lhs: 
                                                                                (sh_lhs_expr.Name
                                                                                  name: droppeddeps
                                                                                )
                                                                              op: Equal
                                                                              rhs: {(yes)}
                                                                            )
                                                                          ]
                                                                        )
                                                                        (C {(echo)})
                                                                        (C 
                                                                          {
                                                                            ($ VSub_DollarName 
'$ECHO'
                                                                            )
                                                                          } {(DQ ('*** Warning: dynamic linker does not accept needed library ') ($ VSub_DollarName '$i') (.))}
                                                                        )
                                                                        (C {(echo)} 
                                                                          {
                                                                            (DQ 
                                                                              (
'*** I have the capability to make that library automatically link in when'
                                                                              )
                                                                            )
                                                                          }
                                                                        )
                                                                        (C {(echo)} 
                                                                          {
                                                                            (DQ 
                                                                              (
'*** you link to this library.  But I can only do this if you have a'
                                                                              )
                                                                            )
                                                                          }
                                                                        )
                                                                        (C {(echo)} 
                                                                          {
                                                                            (DQ 
                                                                              (
'*** shared version of the library, which I believe you do not have'
                                                                              )
                                                                            )
                                                                          }
                                                                        )
                                                                        (C {(echo)} 
                                                                          {
                                                                            (DQ 
                                                                              (
'*** because a test_compile did reveal that the linker did not use it for'
                                                                              )
                                                                            )
                                                                          }
                                                                        )
                                                                        (C {(echo)} 
                                                                          {
                                                                            (DQ 
                                                                              (
'*** its dynamic dependency list that programs get resolved with at runtime.'
                                                                              )
                                                                            )
                                                                          }
                                                                        )
                                                                      ]
                                                                    )
                                                                  ]
                                                                )
                                                              ]
                                                            )
                                                          ]
                                                        )
                                                        (case_arm
                                                          pat_list: [{(Lit_Star '*')}]
                                                          action: [
                                                            (C {(func_append)} {(newdeplibs)} 
                                                              {(DQ (' ') ($ VSub_DollarName '$i'))}
                                                            )
                                                          ]
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                )
                                            )
                                          ]
                                        )
                                      ]
                                      else_action: [
                                        (command.ForEach
                                          iter_name: i
                                          iter_words: [{($ VSub_DollarName '$deplibs')}]
                                          do_arg_iter: F
                                          body: 
                                            (command.DoGroup
                                              children: [
                                                (command.Case
                                                  to_match: {($ VSub_DollarName '$i')}
                                                  arms: [
                                                    (case_arm
                                                      pat_list: [{(-l) (Lit_Star '*')}]
                                                      action: [
                                                        (C {(func_stripname)} {(-l)} {(SQ )} 
                                                          {(DQ ($ VSub_DollarName '$i'))}
                                                        )
                                                        (command.ShAssignment
                                                          pairs: [
                                                            (assign_pair
                                                              lhs: (sh_lhs_expr.Name name:name)
                                                              op: Equal
                                                              rhs: 
                                                                {
                                                                  ($ VSub_DollarName 
'$func_stripname_result'
                                                                  )
                                                                }
                                                            )
                                                          ]
                                                        )
                                                        (command.AndOr
                                                          ops: [Op_DPipe]
                                                          children: [
                                                            (C {($ VSub_DollarName '$opt_dry_run')})
                                                            (C {($ VSub_DollarName '$RM')} {(conftest)})
                                                          ]
                                                        )
                                                        (command.If
                                                          arms: [
                                                            (if_arm
                                                              cond: [
                                                                (command.Sentence
                                                                  child: 
                                                                    (C {($ VSub_DollarName '$LTCC')} 
                                                                      {
                                                                        ($ VSub_DollarName 
'$LTCFLAGS'
                                                                        )
                                                                      } {(-o)} {(conftest)} {(conftest.c)} {($ VSub_DollarName '$i')}
                                                                    )
                                                                  terminator: <Op_Semi ';'>
                                                                )
                                                              ]
                                                              action: [
                                                                (command.ShAssignment
                                                                  pairs: [
                                                                    (assign_pair
                                                                      lhs: 
                                                                        (sh_lhs_expr.Name
                                                                          name: ldd_output
                                                                        )
                                                                      op: Equal
                                                                      rhs: 
                                                                        {
                                                                          (command_sub
                                                                            left_token: 
                                                                              <Left_Backtick '`'>
                                                                            command_list: 
                                                                              (command.CommandList
                                                                                children: [
                                                                                  (C {(ldd)} 
                                                                                    {(conftest)}
                                                                                  )
                                                                                ]
                                                                              )
                                                                          )
                                                                        }
                                                                    )
                                                                  ]
                                                                )
                                                                (command.If
                                                                  arms: [
                                                                    (if_arm
                                                                      cond: [
                                                                        (command.Sentence
                                                                          child: 
                                                                            (C {(test)} {(yes)} 
                                                                              {(Lit_Equals '=')} {(DQ ($ VSub_DollarName '$allow_libtool_libs_with_static_runtimes'))}
                                                                            )
                                                                          terminator: <Op_Semi ';'>
                                                                        )
                                                                      ]
                                                                      action: [
                                                                        (command.Case
                                                                          to_match: 
                                                                            {
                                                                              (DQ (' ') 
                                                                                ($ VSub_DollarName 
'$predeps'
                                                                                ) (' ') ($ VSub_DollarName '$postdeps') (' ')
                                                                              )
                                                                            }
                                                                          arms: [
                                                                            (case_arm
                                                                              pat_list: [
                                                                                {(Lit_Star '*') 
                                                                                  (DQ (' ') 
                                                                                    ($ 
VSub_DollarName '$i'
                                                                                    ) (' ')
                                                                                  ) (Lit_Star '*')
                                                                                }
                                                                              ]
                                                                              action: [
                                                                                (C {(func_append)} 
                                                                                  {(newdeplibs)} {(DQ (' ') ($ VSub_DollarName '$i'))}
                                                                                )
                                                                                (command.ShAssignment
                                                                                  pairs: [
                                                                                    (assign_pair
                                                                                      lhs: 
                                                                                        (sh_lhs_expr.Name
                                                                                          name: i
                                                                                        )
                                                                                      op: Equal
                                                                                      rhs: (word.Empty)
                                                                                    )
                                                                                  ]
                                                                                )
                                                                              ]
                                                                            )
                                                                          ]
                                                                        )
                                                                      ]
                                                                    )
                                                                  ]
                                                                )
                                                                (command.If
                                                                  arms: [
                                                                    (if_arm
                                                                      cond: [
                                                                        (command.Sentence
                                                                          child: 
                                                                            (C {(test)} {(-n)} 
                                                                              {
                                                                                (DQ 
                                                                                  ($ VSub_DollarName 
'$i'
                                                                                  )
                                                                                )
                                                                              }
                                                                            )
                                                                          terminator: <Op_Semi ';'>
                                                                        )
                                                                      ]
                                                                      action: [
                                                                        (command.ShAssignment
                                                                          pairs: [
                                                                            (assign_pair
                                                                              lhs: 
                                                                                (sh_lhs_expr.Name
                                                                                  name: libname
                                                                                )
                                                                              op: Equal
                                                                              rhs: 
                                                                                {
                                                                                  (command_sub
                                                                                    left_token: 
                                                                                      <
Left_Backtick '`'
                                                                                      >
                                                                                    command_list: 
                                                                                      (command.CommandList
                                                                                        children: [
                                                                                          (C {(eval)} 
                                                                                            {
                                                                                              (DQ 
                                                                                                (word_part.EscapedLiteral
                                                                                                  token: 
                                                                                                    <
Lit_EscapedChar '\\$'
                                                                                                    >
                                                                                                ) ('ECHO ')
                                                                                              ) ($ VSub_DollarName '$libname_spec') (DQ )
                                                                                            }
                                                                                          )
                                                                                        ]
                                                                                      )
                                                                                  )
                                                                                }
                                                                            )
                                                                          ]
                                                                        )
                                                                        (command.ShAssignment
                                                                          pairs: [
                                                                            (assign_pair
                                                                              lhs: 
                                                                                (sh_lhs_expr.Name
                                                                                  name: 
deplib_matches
                                                                                )
                                                                              op: Equal
                                                                              rhs: 
                                                                                {
                                                                                  (command_sub
                                                                                    left_token: 
                                                                                      <
Left_Backtick '`'
                                                                                      >
                                                                                    command_list: 
                                                                                      (command.CommandList
                                                                                        children: [
                                                                                          (C {(eval)} 
                                                                                            {
                                                                                              (DQ 
                                                                                                (word_part.EscapedLiteral
                                                                                                  token: 
                                                                                                    <
Lit_EscapedChar '\\$'
                                                                                                    >
                                                                                                ) ('ECHO ')
                                                                                              ) ($ VSub_DollarName '$library_names_spec') (DQ )
                                                                                            }
                                                                                          )
                                                                                        ]
                                                                                      )
                                                                                  )
                                                                                }
                                                                            )
                                                                          ]
                                                                        )
                                                                        (command.Sentence
                                                                          child: 
                                                                            (C {(KW_Set set)} {(dummy)} 
                                                                              {
                                                                                ($ VSub_DollarName 
'$deplib_matches'
                                                                                )
                                                                              }
                                                                            )
                                                                          terminator: <Op_Semi ';'>
                                                                        )
                                                                        (C {(shift)})
                                                                        (command.ShAssignment
                                                                          pairs: [
                                                                            (assign_pair
                                                                              lhs: 
                                                                                (sh_lhs_expr.Name
                                                                                  name: deplib_match
                                                                                )
                                                                              op: Equal
                                                                              rhs: 
                                                                                {
                                                                                  ($ VSub_Number '$1')
                                                                                }
                                                                            )
                                                                          ]
                                                                        )
                                                                        (command.If
                                                                          arms: [
                                                                            (if_arm
                                                                              cond: [
                                                                                (command.Sentence
                                                                                  child: 
                                                                                    (C {(test)} 
                                                                                      {
                                                                                        (command_sub
                                                                                          left_token: 
                                                                                            <
Left_Backtick '`'
                                                                                            >
                                                                                          command_list: 
                                                                                            (command.CommandList
                                                                                              children: [
                                                                                                (C 
                                                                                                  {
                                                                                                    (
expr
                                                                                                    )
                                                                                                  } {(DQ ($ VSub_DollarName '$ldd_output'))} {(Lit_Other ':')} 
                                                                                                  {
                                                                                                    (DQ 
                                                                                                      (
'.*'
                                                                                                      ) ($ VSub_DollarName '$deplib_match')
                                                                                                    )
                                                                                                  }
                                                                                                )
                                                                                              ]
                                                                                            )
                                                                                        )
                                                                                      } {(-ne)} {(0)}
                                                                                    )
                                                                                  terminator: 
                                                                                    <Op_Semi ';'>
                                                                                )
                                                                              ]
                                                                              action: [
                                                                                (C {(func_append)} 
                                                                                  {(newdeplibs)} {(DQ (' ') ($ VSub_DollarName '$i'))}
                                                                                )
                                                                              ]
                                                                            )
                                                                          ]
                                                                          else_action: [
                                                                            (command.ShAssignment
                                                                              pairs: [
                                                                                (assign_pair
                                                                                  lhs: 
                                                                                    (sh_lhs_expr.Name
                                                                                      name: 
droppeddeps
                                                                                    )
                                                                                  op: Equal
                                                                                  rhs: {(yes)}
                                                                                )
                                                                              ]
                                                                            )
                                                                            (C {(echo)})
                                                                            (C 
                                                                              {
                                                                                ($ VSub_DollarName 
'$ECHO'
                                                                                )
                                                                              } {(DQ ('*** Warning: dynamic linker does not accept needed library ') ($ VSub_DollarName '$i') (.))}
                                                                            )
                                                                            (C {(echo)} 
                                                                              {
                                                                                (DQ 
                                                                                  (
'*** I have the capability to make that library automatically link in when'
                                                                                  )
                                                                                )
                                                                              }
                                                                            )
                                                                            (C {(echo)} 
                                                                              {
                                                                                (DQ 
                                                                                  (
'*** you link to this library.  But I can only do this if you have a'
                                                                                  )
                                                                                )
                                                                              }
                                                                            )
                                                                            (C {(echo)} 
                                                                              {
                                                                                (DQ 
                                                                                  (
'*** shared version of the library, which you do not appear to have'
                                                                                  )
                                                                                )
                                                                              }
                                                                            )
                                                                            (C {(echo)} 
                                                                              {
                                                                                (DQ 
                                                                                  (
'*** because a test_compile did reveal that the linker did not use this one'
                                                                                  )
                                                                                )
                                                                              }
                                                                            )
                                                                            (C {(echo)} 
                                                                              {
                                                                                (DQ 
                                                                                  (
'*** as a dynamic dependency that programs can get resolved with at runtime.'
                                                                                  )
                                                                                )
                                                                              }
                                                                            )
                                                                          ]
                                                                        )
                                                                      ]
                                                                    )
                                                                  ]
                                                                )
                                                              ]
                                                            )
                                                          ]
                                                          else_action: [
                                                            (command.ShAssignment
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: 
                                                                    (sh_lhs_expr.Name
                                                                      name: droppeddeps
                                                                    )
                                                                  op: Equal
                                                                  rhs: {(yes)}
                                                                )
                                                              ]
                                                            )
                                                            (C {(echo)})
                                                            (C {($ VSub_DollarName '$ECHO')} 
                                                              {
                                                                (DQ ('*** Warning!  Library ') 
                                                                  ($ VSub_DollarName '$i') (' is needed by this library but I was not able to')
                                                                )
                                                              }
                                                            )
                                                            (C {(echo)} 
                                                              {
                                                                (DQ 
                                                                  (
'*** make it link in!  You will probably need to install it or some'
                                                                  )
                                                                )
                                                              }
                                                            )
                                                            (C {(echo)} 
                                                              {
                                                                (DQ 
                                                                  (
'*** library that it depends on before this library will be fully'
                                                                  )
                                                                )
                                                              }
                                                            )
                                                            (C {(echo)} 
                                                              {
                                                                (DQ 
                                                                  (
'*** functional.  Installing it before continuing would be even better.'
                                                                  )
                                                                )
                                                              }
                                                            )
                                                          ]
                                                        )
                                                      ]
                                                    )
                                                    (case_arm
                                                      pat_list: [{(Lit_Star '*')}]
                                                      action: [
                                                        (C {(func_append)} {(newdeplibs)} 
                                                          {(DQ (' ') ($ VSub_DollarName '$i'))}
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                )
                                              ]
                                            )
                                        )
                                      ]
                                    )
                                  ]
                                )
                                (case_arm
                                  pat_list: [{(file_magic) (Lit_Star '*')}]
                                  action: [
                                    (command.Sentence
                                      child: 
                                        (C {(KW_Set set)} {(dummy)} 
                                          {($ VSub_DollarName '$deplibs_check_method')}
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                    (C {(shift)})
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:file_magic_regex)
                                          op: Equal
                                          rhs: 
                                            {
                                              (command_sub
                                                left_token: <Left_Backtick '`'>
                                                command_list: 
                                                  (command.CommandList
                                                    children: [
                                                      (C {(expr)} 
                                                        {
                                                          (DQ 
                                                            ($ VSub_DollarName 
'$deplibs_check_method'
                                                            )
                                                          )
                                                        } {(Lit_Other ':')} {(DQ ($ VSub_Number '$1') (' ') (Lit_Other '\\') ('(.*') (Lit_Other '\\') (')'))}
                                                      )
                                                    ]
                                                  )
                                              )
                                            }
                                        )
                                      ]
                                    )
                                    (command.ForEach
                                      iter_name: a_deplib
                                      iter_words: [{($ VSub_DollarName '$deplibs')}]
                                      do_arg_iter: F
                                      body: 
                                        (command.DoGroup
                                          children: [
                                            (command.Case
                                              to_match: {($ VSub_DollarName '$a_deplib')}
                                              arms: [
                                                (case_arm
                                                  pat_list: [{(-l) (Lit_Star '*')}]
                                                  action: [
                                                    (C {(func_stripname)} {(-l)} {(SQ )} 
                                                      {(DQ ($ VSub_DollarName '$a_deplib'))}
                                                    )
                                                    (command.ShAssignment
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (sh_lhs_expr.Name name:name)
                                                          op: Equal
                                                          rhs: 
                                                            {
                                                              ($ VSub_DollarName 
'$func_stripname_result'
                                                              )
                                                            }
                                                        )
                                                      ]
                                                    )
                                                    (command.If
                                                      arms: [
                                                        (if_arm
                                                          cond: [
                                                            (command.Sentence
                                                              child: 
                                                                (C {(test)} {(yes)} {(Lit_Equals '=')} 
                                                                  {
                                                                    (DQ 
                                                                      ($ VSub_DollarName 
'$allow_libtool_libs_with_static_runtimes'
                                                                      )
                                                                    )
                                                                  }
                                                                )
                                                              terminator: <Op_Semi ';'>
                                                            )
                                                          ]
                                                          action: [
                                                            (command.Case
                                                              to_match: 
                                                                {
                                                                  (DQ (' ') 
                                                                    ($ VSub_DollarName '$predeps') (' ') ($ VSub_DollarName '$postdeps') (' ')
                                                                  )
                                                                }
                                                              arms: [
                                                                (case_arm
                                                                  pat_list: [
                                                                    {(Lit_Star '*') 
                                                                      (DQ (' ') 
                                                                        ($ VSub_DollarName 
'$a_deplib'
                                                                        ) (' ')
                                                                      ) (Lit_Star '*')
                                                                    }
                                                                  ]
                                                                  action: [
                                                                    (C {(func_append)} {(newdeplibs)} 
                                                                      {
                                                                        (DQ (' ') 
                                                                          ($ VSub_DollarName 
'$a_deplib'
                                                                          )
                                                                        )
                                                                      }
                                                                    )
                                                                    (command.ShAssignment
                                                                      pairs: [
                                                                        (assign_pair
                                                                          lhs: 
                                                                            (sh_lhs_expr.Name
                                                                              name: a_deplib
                                                                            )
                                                                          op: Equal
                                                                          rhs: (word.Empty)
                                                                        )
                                                                      ]
                                                                    )
                                                                  ]
                                                                )
                                                              ]
                                                            )
                                                          ]
                                                        )
                                                      ]
                                                    )
                                                    (command.If
                                                      arms: [
                                                        (if_arm
                                                          cond: [
                                                            (command.Sentence
                                                              child: 
                                                                (C {(test)} {(-n)} 
                                                                  {
                                                                    (DQ 
                                                                      ($ VSub_DollarName '$a_deplib')
                                                                    )
                                                                  }
                                                                )
                                                              terminator: <Op_Semi ';'>
                                                            )
                                                          ]
                                                          action: [
                                                            (command.ShAssignment
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: 
                                                                    (sh_lhs_expr.Name
                                                                      name: libname
                                                                    )
                                                                  op: Equal
                                                                  rhs: 
                                                                    {
                                                                      (command_sub
                                                                        left_token: 
                                                                          <Left_Backtick '`'>
                                                                        command_list: 
                                                                          (command.CommandList
                                                                            children: [
                                                                              (C {(eval)} 
                                                                                {
                                                                                  (DQ 
                                                                                    (word_part.EscapedLiteral
                                                                                      token: 
                                                                                        <
Lit_EscapedChar '\\$'
                                                                                        >
                                                                                    ) ('ECHO ')
                                                                                  ) ($ VSub_DollarName '$libname_spec') (DQ )
                                                                                }
                                                                              )
                                                                            ]
                                                                          )
                                                                      )
                                                                    }
                                                                )
                                                              ]
                                                            )
                                                            (command.If
                                                              arms: [
                                                                (if_arm
                                                                  cond: [
                                                                    (command.Sentence
                                                                      child: 
                                                                        (C {(test)} {(-n)} 
                                                                          {
                                                                            (DQ 
                                                                              ($ VSub_DollarName 
'$file_magic_glob'
                                                                              )
                                                                            )
                                                                          }
                                                                        )
                                                                      terminator: <Op_Semi ';'>
                                                                    )
                                                                  ]
                                                                  action: [
                                                                    (command.ShAssignment
                                                                      pairs: [
                                                                        (assign_pair
                                                                          lhs: 
                                                                            (sh_lhs_expr.Name
                                                                              name: libnameglob
                                                                            )
                                                                          op: Equal
                                                                          rhs: 
                                                                            {
                                                                              (command_sub
                                                                                left_token: 
                                                                                  <Left_Backtick '`'>
                                                                                command_list: 
                                                                                  (command.CommandList
                                                                                    children: [
                                                                                      (command.Pipeline
                                                                                        children: [
                                                                                          (C 
                                                                                            {
                                                                                              (
func_echo_all
                                                                                              )
                                                                                            } {(DQ ($ VSub_DollarName '$libname'))}
                                                                                          )
                                                                                          (C 
                                                                                            {
                                                                                              ($ 
VSub_DollarName '$SED'
                                                                                              )
                                                                                            } {(-e)} {($ VSub_DollarName '$file_magic_glob')}
                                                                                          )
                                                                                        ]
                                                                                        negated: F
                                                                                      )
                                                                                    ]
                                                                                  )
                                                                              )
                                                                            }
                                                                        )
                                                                      ]
                                                                    )
                                                                  ]
                                                                )
                                                              ]
                                                              else_action: [
                                                                (command.ShAssignment
                                                                  pairs: [
                                                                    (assign_pair
                                                                      lhs: 
                                                                        (sh_lhs_expr.Name
                                                                          name: libnameglob
                                                                        )
                                                                      op: Equal
                                                                      rhs: 
                                                                        {
                                                                          ($ VSub_DollarName 
'$libname'
                                                                          )
                                                                        }
                                                                    )
                                                                  ]
                                                                )
                                                              ]
                                                            )
                                                            (command.AndOr
                                                              ops: [Op_DAmp]
                                                              children: [
                                                                (C {(test)} {(yes)} {(Lit_Equals '=')} 
                                                                  {
                                                                    (DQ 
                                                                      ($ VSub_DollarName 
'$want_nocaseglob'
                                                                      )
                                                                    )
                                                                  }
                                                                )
                                                                (command.ShAssignment
                                                                  pairs: [
                                                                    (assign_pair
                                                                      lhs: 
                                                                        (sh_lhs_expr.Name
                                                                          name: nocaseglob
                                                                        )
                                                                      op: Equal
                                                                      rhs: 
                                                                        {
                                                                          (command_sub
                                                                            left_token: 
                                                                              <Left_Backtick '`'>
                                                                            command_list: 
                                                                              (command.CommandList
                                                                                children: [
                                                                                  (C {(shopt)} {(-p)} 
                                                                                    {(nocaseglob)}
                                                                                  )
                                                                                ]
                                                                              )
                                                                          )
                                                                        }
                                                                    )
                                                                  ]
                                                                )
                                                              ]
                                                            )
                                                            (command.ForEach
                                                              iter_name: i
                                                              iter_words: [
                                                                {
                                                                  ($ VSub_DollarName 
'$lib_search_path'
                                                                  )
                                                                }
                                                                {
                                                                  ($ VSub_DollarName 
'$sys_lib_search_path'
                                                                  )
                                                                }
                                                                {
                                                                  ($ VSub_DollarName 
'$shlib_search_path'
                                                                  )
                                                                }
                                                              ]
                                                              do_arg_iter: F
                                                              body: 
                                                                (command.DoGroup
                                                                  children: [
                                                                    (command.If
                                                                      arms: [
                                                                        (if_arm
                                                                          cond: [
                                                                            (command.Sentence
                                                                              child: 
                                                                                (C {(test)} {(yes)} 
                                                                                  {(Lit_Equals '=')} {(DQ ($ VSub_DollarName '$want_nocaseglob'))}
                                                                                )
                                                                              terminator: 
                                                                                <Op_Semi ';'>
                                                                            )
                                                                          ]
                                                                          action: [
                                                                            (C {(shopt)} {(-s)} 
                                                                              {(nocaseglob)}
                                                                            )
                                                                            (command.ShAssignment
                                                                              pairs: [
                                                                                (assign_pair
                                                                                  lhs: 
                                                                                    (sh_lhs_expr.Name
                                                                                      name: 
potential_libs
                                                                                    )
                                                                                  op: Equal
                                                                                  rhs: 
                                                                                    {
                                                                                      (command_sub
                                                                                        left_token: 
                                                                                          <
Left_Backtick '`'
                                                                                          >
                                                                                        command_list: 
                                                                                          (command.CommandList
                                                                                            children: [
                                                                                              (command.Simple
                                                                                                words: [
                                                                                                  {
                                                                                                    (
ls
                                                                                                    )
                                                                                                  }
                                                                                                  {
                                                                                                    ($ 
VSub_DollarName '$i'
                                                                                                    ) (/) ($ VSub_DollarName '$libnameglob') (Lit_LBracket '[') (.-) (Lit_RBracket ']') (Lit_Star '*')
                                                                                                  }
                                                                                                ]
                                                                                                redirects: [
                                                                                                  (redir.Redir
                                                                                                    op: 
                                                                                                      <
Redir_Great '2>'
                                                                                                      >
                                                                                                    fd: 
2
                                                                                                    arg_word: 
                                                                                                      {
                                                                                                        (
/dev/null
                                                                                                        )
                                                                                                      }
                                                                                                  )
                                                                                                ]
                                                                                              )
                                                                                            ]
                                                                                          )
                                                                                      )
                                                                                    }
                                                                                )
                                                                              ]
                                                                            )
                                                                            (C 
                                                                              {
                                                                                ($ VSub_DollarName 
'$nocaseglob'
                                                                                )
                                                                              }
                                                                            )
                                                                          ]
                                                                        )
                                                                      ]
                                                                      else_action: [
                                                                        (command.ShAssignment
                                                                          pairs: [
                                                                            (assign_pair
                                                                              lhs: 
                                                                                (sh_lhs_expr.Name
                                                                                  name: 
potential_libs
                                                                                )
                                                                              op: Equal
                                                                              rhs: 
                                                                                {
                                                                                  (command_sub
                                                                                    left_token: 
                                                                                      <
Left_Backtick '`'
                                                                                      >
                                                                                    command_list: 
                                                                                      (command.CommandList
                                                                                        children: [
                                                                                          (command.Simple
                                                                                            words: [
                                                                                              {(ls)}
                                                                                              {
                                                                                                ($ 
VSub_DollarName '$i'
                                                                                                ) (/) ($ VSub_DollarName '$libnameglob') (Lit_LBracket '[') (.-) (Lit_RBracket ']') (Lit_Star '*')
                                                                                              }
                                                                                            ]
                                                                                            redirects: [
                                                                                              (redir.Redir
                                                                                                op: 
                                                                                                  <
Redir_Great '2>'
                                                                                                  >
                                                                                                fd: 
2
                                                                                                arg_word: 
                                                                                                  {
                                                                                                    (
/dev/null
                                                                                                    )
                                                                                                  }
                                                                                              )
                                                                                            ]
                                                                                          )
                                                                                        ]
                                                                                      )
                                                                                  )
                                                                                }
                                                                            )
                                                                          ]
                                                                        )
                                                                      ]
                                                                    )
                                                                    (command.ForEach
                                                                      iter_name: potent_lib
                                                                      iter_words: [
                                                                        {
                                                                          ($ VSub_DollarName 
'$potential_libs'
                                                                          )
                                                                        }
                                                                      ]
                                                                      do_arg_iter: F
                                                                      body: 
                                                                        (command.DoGroup
                                                                          children: [
                                                                            (command.If
                                                                              arms: [
                                                                                (if_arm
                                                                                  cond: [
                                                                                    (command.Sentence
                                                                                      child: 
                                                                                        (command.Pipeline
                                                                                          children: [
                                                                                            (command.Simple
                                                                                              words: [
                                                                                                {
                                                                                                  (
ls
                                                                                                  )
                                                                                                }
                                                                                                {
                                                                                                  (
-lLd
                                                                                                  )
                                                                                                }
                                                                                                {
                                                                                                  (DQ 
                                                                                                    ($ 
VSub_DollarName '$potent_lib'
                                                                                                    )
                                                                                                  )
                                                                                                }
                                                                                              ]
                                                                                              redirects: [
                                                                                                (redir.Redir
                                                                                                  op: 
                                                                                                    <
Redir_Great '2>'
                                                                                                    >
                                                                                                  fd: 
2
                                                                                                  arg_word: 
                                                                                                    {
                                                                                                      (
/dev/null
                                                                                                      )
                                                                                                    }
                                                                                                )
                                                                                              ]
                                                                                            )
                                                                                            (command.Simple
                                                                                              words: [
                                                                                                {
                                                                                                  ($ 
VSub_DollarName '$GREP'
                                                                                                  )
                                                                                                }
                                                                                                {
                                                                                                  (DQ 
                                                                                                    (
' -> '
                                                                                                    )
                                                                                                  )
                                                                                                }
                                                                                              ]
                                                                                              redirects: [
                                                                                                (redir.Redir
                                                                                                  op: 
                                                                                                    <
Redir_Great '>'
                                                                                                    >
                                                                                                  fd: 
16777215
                                                                                                  arg_word: 
                                                                                                    {
                                                                                                      (
/dev/null
                                                                                                      )
                                                                                                    }
                                                                                                )
                                                                                              ]
                                                                                            )
                                                                                          ]
                                                                                          negated: F
                                                                                        )
                                                                                      terminator: 
                                                                                        <Op_Semi ';'>
                                                                                    )
                                                                                  ]
                                                                                  action: [
                                                                                    (command.ControlFlow
                                                                                      token: 
                                                                                        <
ControlFlow_Continue continue
                                                                                        >
                                                                                    )
                                                                                  ]
                                                                                )
                                                                              ]
                                                                            )
                                                                            (command.ShAssignment
                                                                              pairs: [
                                                                                (assign_pair
                                                                                  lhs: 
                                                                                    (sh_lhs_expr.Name
                                                                                      name: potlib
                                                                                    )
                                                                                  op: Equal
                                                                                  rhs: 
                                                                                    {
                                                                                      ($ 
VSub_DollarName '$potent_lib'
                                                                                      )
                                                                                    }
                                                                                )
                                                                              ]
                                                                            )
                                                                            (command.WhileUntil
                                                                              keyword: 
                                                                                <KW_While while>
                                                                              cond: [
                                                                                (command.Sentence
                                                                                  child: 
                                                                                    (command.Simple
                                                                                      words: [
                                                                                        {(test)}
                                                                                        {(-h)}
                                                                                        {
                                                                                          (DQ 
                                                                                            ($ 
VSub_DollarName '$potlib'
                                                                                            )
                                                                                          )
                                                                                        }
                                                                                      ]
                                                                                      redirects: [
                                                                                        (redir.Redir
                                                                                          op: 
                                                                                            <
Redir_Great '2>'
                                                                                            >
                                                                                          fd: 2
                                                                                          arg_word: 
                                                                                            {
                                                                                              (
/dev/null
                                                                                              )
                                                                                            }
                                                                                        )
                                                                                      ]
                                                                                    )
                                                                                  terminator: 
                                                                                    <Op_Semi ';'>
                                                                                )
                                                                              ]
                                                                              body: 
                                                                                (command.DoGroup
                                                                                  children: [
                                                                                    (command.ShAssignment
                                                                                      pairs: [
                                                                                        (assign_pair
                                                                                          lhs: 
                                                                                            (sh_lhs_expr.Name
                                                                                              name: 
potliblink
                                                                                            )
                                                                                          op: Equal
                                                                                          rhs: 
                                                                                            {
                                                                                              (command_sub
                                                                                                left_token: 
                                                                                                  <
Left_Backtick '`'
                                                                                                  >
                                                                                                command_list: 
                                                                                                  (command.CommandList
                                                                                                    children: [
                                                                                                      (command.Pipeline
                                                                                                        children: [
                                                                                                          (C 
                                                                                                            {
                                                                                                              (
ls
                                                                                                              )
                                                                                                            } {(-ld)} {($ VSub_DollarName '$potlib')}
                                                                                                          )
                                                                                                          (C 
                                                                                                            {
                                                                                                              ($ 
VSub_DollarName '$SED'
                                                                                                              )
                                                                                                            } {(SQ <'s/.* -> //'>)}
                                                                                                          )
                                                                                                        ]
                                                                                                        negated: 
F
                                                                                                      )
                                                                                                    ]
                                                                                                  )
                                                                                              )
                                                                                            }
                                                                                        )
                                                                                      ]
                                                                                    )
                                                                                    (command.Case
                                                                                      to_match: 
                                                                                        {
                                                                                          ($ 
VSub_DollarName '$potliblink'
                                                                                          )
                                                                                        }
                                                                                      arms: [
                                                                                        (case_arm
                                                                                          pat_list: [
                                                                                            {
                                                                                              (
Lit_LBracket '['
                                                                                              ) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\\\'>) (/) (Lit_RBracket ']') (Lit_Star '*')
                                                                                            }
                                                                                            {
                                                                                              (
Lit_LBracket '['
                                                                                              ) (A-Za-z) (Lit_RBracket ']') (Lit_Other ':') (Lit_LBracket '[') 
                                                                                              (word_part.EscapedLiteral
                                                                                                token: 
                                                                                                  <
Lit_EscapedChar '\\\\'
                                                                                                  >
                                                                                              ) (/) (Lit_RBracket ']') (Lit_Star '*')
                                                                                            }
                                                                                          ]
                                                                                          action: [
                                                                                            (command.ShAssignment
                                                                                              pairs: [
                                                                                                (assign_pair
                                                                                                  lhs: 
                                                                                                    (sh_lhs_expr.Name
                                                                                                      name: 
potlib
                                                                                                    )
                                                                                                  op: 
Equal
                                                                                                  rhs: 
                                                                                                    {
                                                                                                      ($ 
VSub_DollarName '$potliblink'
                                                                                                      )
                                                                                                    }
                                                                                                )
                                                                                              ]
                                                                                            )
                                                                                          ]
                                                                                        )
                                                                                        (case_arm
                                                                                          pat_list: [
                                                                                            {
                                                                                              (
Lit_Star '*'
                                                                                              )
                                                                                            }
                                                                                          ]
                                                                                          action: [
                                                                                            (command.ShAssignment
                                                                                              pairs: [
                                                                                                (assign_pair
                                                                                                  lhs: 
                                                                                                    (sh_lhs_expr.Name
                                                                                                      name: 
potlib
                                                                                                    )
                                                                                                  op: 
Equal
                                                                                                  rhs: 
                                                                                                    {
                                                                                                      (command_sub
                                                                                                        left_token: 
                                                                                                          <
Left_Backtick '`'
                                                                                                          >
                                                                                                        command_list: 
                                                                                                          (command.CommandList
                                                                                                            children: [
                                                                                                              (command.Pipeline
                                                                                                                children: [
                                                                                                                  (C 
                                                                                                                    {
                                                                                                                      ($ 
VSub_DollarName '$ECHO'
                                                                                                                      )
                                                                                                                    } {(DQ ($ VSub_DollarName '$potlib'))}
                                                                                                                  )
                                                                                                                  (C 
                                                                                                                    {
                                                                                                                      ($ 
VSub_DollarName '$SED'
                                                                                                                      )
                                                                                                                    } {(SQ <'s|[^/]*$||'>)}
                                                                                                                  )
                                                                                                                ]
                                                                                                                negated: 
F
                                                                                                              )
                                                                                                            ]
                                                                                                          )
                                                                                                      ) (DQ ($ VSub_DollarName '$potliblink'))
                                                                                                    }
                                                                                                )
                                                                                              ]
                                                                                            )
                                                                                          ]
                                                                                        )
                                                                                      ]
                                                                                    )
                                                                                  ]
                                                                                )
                                                                            )
                                                                            (command.If
                                                                              arms: [
                                                                                (if_arm
                                                                                  cond: [
                                                                                    (command.Sentence
                                                                                      child: 
                                                                                        (command.Pipeline
                                                                                          children: [
                                                                                            (command.Simple
                                                                                              words: [
                                                                                                {
                                                                                                  (
eval
                                                                                                  )
                                                                                                }
                                                                                                {
                                                                                                  ($ 
VSub_DollarName '$file_magic_cmd'
                                                                                                  )
                                                                                                }
                                                                                                {
                                                                                                  (word_part.EscapedLiteral
                                                                                                    token: 
                                                                                                      <
Lit_EscapedChar '\\"'
                                                                                                      >
                                                                                                  ) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) (potlib) 
                                                                                                  (word_part.EscapedLiteral
                                                                                                    token: 
                                                                                                      <
Lit_EscapedChar '\\"'
                                                                                                      >
                                                                                                  )
                                                                                                }
                                                                                              ]
                                                                                              redirects: [
                                                                                                (redir.Redir
                                                                                                  op: 
                                                                                                    <
Redir_Great '2>'
                                                                                                    >
                                                                                                  fd: 
2
                                                                                                  arg_word: 
                                                                                                    {
                                                                                                      (
/dev/null
                                                                                                      )
                                                                                                    }
                                                                                                )
                                                                                              ]
                                                                                            )
                                                                                            (C 
                                                                                              {
                                                                                                ($ 
VSub_DollarName '$SED'
                                                                                                )
                                                                                              } {(-e)} {(10q)}
                                                                                            )
                                                                                            (command.Simple
                                                                                              words: [
                                                                                                {
                                                                                                  ($ 
VSub_DollarName '$EGREP'
                                                                                                  )
                                                                                                }
                                                                                                {
                                                                                                  (DQ 
                                                                                                    ($ 
VSub_DollarName '$file_magic_regex'
                                                                                                    )
                                                                                                  )
                                                                                                }
                                                                                              ]
                                                                                              redirects: [
                                                                                                (redir.Redir
                                                                                                  op: 
                                                                                                    <
Redir_Great '>'
                                                                                                    >
                                                                                                  fd: 
16777215
                                                                                                  arg_word: 
                                                                                                    {
                                                                                                      (
/dev/null
                                                                                                      )
                                                                                                    }
                                                                                                )
                                                                                              ]
                                                                                            )
                                                                                          ]
                                                                                          negated: F
                                                                                        )
                                                                                      terminator: 
                                                                                        <Op_Semi ';'>
                                                                                    )
                                                                                  ]
                                                                                  action: [
                                                                                    (C {(func_append)} 
                                                                                      {(newdeplibs)} {(DQ (' ') ($ VSub_DollarName '$a_deplib'))}
                                                                                    )
                                                                                    (command.ShAssignment
                                                                                      pairs: [
                                                                                        (assign_pair
                                                                                          lhs: 
                                                                                            (sh_lhs_expr.Name
                                                                                              name: 
a_deplib
                                                                                            )
                                                                                          op: Equal
                                                                                          rhs: (word.Empty)
                                                                                        )
                                                                                      ]
                                                                                    )
                                                                                    (command.ControlFlow
                                                                                      token: 
                                                                                        <
ControlFlow_Break break
                                                                                        >
                                                                                      arg_word: {(2)}
                                                                                    )
                                                                                  ]
                                                                                )
                                                                              ]
                                                                            )
                                                                          ]
                                                                        )
                                                                    )
                                                                  ]
                                                                )
                                                            )
                                                          ]
                                                        )
                                                      ]
                                                    )
                                                    (command.If
                                                      arms: [
                                                        (if_arm
                                                          cond: [
                                                            (command.Sentence
                                                              child: 
                                                                (C {(test)} {(-n)} 
                                                                  {
                                                                    (DQ 
                                                                      ($ VSub_DollarName '$a_deplib')
                                                                    )
                                                                  }
                                                                )
                                                              terminator: <Op_Semi ';'>
                                                            )
                                                          ]
                                                          action: [
                                                            (command.ShAssignment
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: 
                                                                    (sh_lhs_expr.Name
                                                                      name: droppeddeps
                                                                    )
                                                                  op: Equal
                                                                  rhs: {(yes)}
                                                                )
                                                              ]
                                                            )
                                                            (C {(echo)})
                                                            (C {($ VSub_DollarName '$ECHO')} 
                                                              {
                                                                (DQ 
                                                                  (
'*** Warning: linker path does not have real file for library '
                                                                  ) ($ VSub_DollarName '$a_deplib') (.)
                                                                )
                                                              }
                                                            )
                                                            (C {(echo)} 
                                                              {
                                                                (DQ 
                                                                  (
'*** I have the capability to make that library automatically link in when'
                                                                  )
                                                                )
                                                              }
                                                            )
                                                            (C {(echo)} 
                                                              {
                                                                (DQ 
                                                                  (
'*** you link to this library.  But I can only do this if you have a'
                                                                  )
                                                                )
                                                              }
                                                            )
                                                            (C {(echo)} 
                                                              {
                                                                (DQ 
                                                                  (
'*** shared version of the library, which you do not appear to have'
                                                                  )
                                                                )
                                                              }
                                                            )
                                                            (C {(echo)} 
                                                              {
                                                                (DQ 
                                                                  (
'*** because I did check the linker path looking for a file starting'
                                                                  )
                                                                )
                                                              }
                                                            )
                                                            (command.If
                                                              arms: [
                                                                (if_arm
                                                                  cond: [
                                                                    (command.Sentence
                                                                      child: 
                                                                        (C {(test)} {(-z)} 
                                                                          {
                                                                            (DQ 
                                                                              ($ VSub_DollarName 
'$potlib'
                                                                              )
                                                                            )
                                                                          }
                                                                        )
                                                                      terminator: <Op_Semi ';'>
                                                                    )
                                                                  ]
                                                                  action: [
                                                                    (C {($ VSub_DollarName '$ECHO')} 
                                                                      {
                                                                        (DQ ('*** with ') 
                                                                          ($ VSub_DollarName 
'$libname'
                                                                          ) (' but no candidates were found. (...for file magic test)')
                                                                        )
                                                                      }
                                                                    )
                                                                  ]
                                                                )
                                                              ]
                                                              else_action: [
                                                                (C {($ VSub_DollarName '$ECHO')} 
                                                                  {
                                                                    (DQ ('*** with ') 
                                                                      ($ VSub_DollarName '$libname') (' and none of the candidates passed a file format test')
                                                                    )
                                                                  }
                                                                )
                                                                (C {($ VSub_DollarName '$ECHO')} 
                                                                  {
                                                                    (DQ 
                                                                      (
'*** using a file magic. Last file checked: '
                                                                      ) ($ VSub_DollarName '$potlib')
                                                                    )
                                                                  }
                                                                )
                                                              ]
                                                            )
                                                          ]
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                )
                                                (case_arm
                                                  pat_list: [{(Lit_Star '*')}]
                                                  action: [
                                                    (C {(func_append)} {(newdeplibs)} 
                                                      {(DQ (' ') ($ VSub_DollarName '$a_deplib'))}
                                                    )
                                                  ]
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                    )
                                  ]
                                )
                                (case_arm
                                  pat_list: [{(match_pattern) (Lit_Star '*')}]
                                  action: [
                                    (command.Sentence
                                      child: 
                                        (C {(KW_Set set)} {(dummy)} 
                                          {($ VSub_DollarName '$deplibs_check_method')}
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                    (C {(shift)})
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:match_pattern_regex)
                                          op: Equal
                                          rhs: 
                                            {
                                              (command_sub
                                                left_token: <Left_Backtick '`'>
                                                command_list: 
                                                  (command.CommandList
                                                    children: [
                                                      (C {(expr)} 
                                                        {
                                                          (DQ 
                                                            ($ VSub_DollarName 
'$deplibs_check_method'
                                                            )
                                                          )
                                                        } {(Lit_Other ':')} {(DQ ($ VSub_Number '$1') (' ') (Lit_Other '\\') ('(.*') (Lit_Other '\\') (')'))}
                                                      )
                                                    ]
                                                  )
                                              )
                                            }
                                        )
                                      ]
                                    )
                                    (command.ForEach
                                      iter_name: a_deplib
                                      iter_words: [{($ VSub_DollarName '$deplibs')}]
                                      do_arg_iter: F
                                      body: 
                                        (command.DoGroup
                                          children: [
                                            (command.Case
                                              to_match: {($ VSub_DollarName '$a_deplib')}
                                              arms: [
                                                (case_arm
                                                  pat_list: [{(-l) (Lit_Star '*')}]
                                                  action: [
                                                    (C {(func_stripname)} {(-l)} {(SQ )} 
                                                      {(DQ ($ VSub_DollarName '$a_deplib'))}
                                                    )
                                                    (command.ShAssignment
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (sh_lhs_expr.Name name:name)
                                                          op: Equal
                                                          rhs: 
                                                            {
                                                              ($ VSub_DollarName 
'$func_stripname_result'
                                                              )
                                                            }
                                                        )
                                                      ]
                                                    )
                                                    (command.If
                                                      arms: [
                                                        (if_arm
                                                          cond: [
                                                            (command.Sentence
                                                              child: 
                                                                (C {(test)} {(yes)} {(Lit_Equals '=')} 
                                                                  {
                                                                    (DQ 
                                                                      ($ VSub_DollarName 
'$allow_libtool_libs_with_static_runtimes'
                                                                      )
                                                                    )
                                                                  }
                                                                )
                                                              terminator: <Op_Semi ';'>
                                                            )
                                                          ]
                                                          action: [
                                                            (command.Case
                                                              to_match: 
                                                                {
                                                                  (DQ (' ') 
                                                                    ($ VSub_DollarName '$predeps') (' ') ($ VSub_DollarName '$postdeps') (' ')
                                                                  )
                                                                }
                                                              arms: [
                                                                (case_arm
                                                                  pat_list: [
                                                                    {(Lit_Star '*') 
                                                                      (DQ (' ') 
                                                                        ($ VSub_DollarName 
'$a_deplib'
                                                                        ) (' ')
                                                                      ) (Lit_Star '*')
                                                                    }
                                                                  ]
                                                                  action: [
                                                                    (C {(func_append)} {(newdeplibs)} 
                                                                      {
                                                                        (DQ (' ') 
                                                                          ($ VSub_DollarName 
'$a_deplib'
                                                                          )
                                                                        )
                                                                      }
                                                                    )
                                                                    (command.ShAssignment
                                                                      pairs: [
                                                                        (assign_pair
                                                                          lhs: 
                                                                            (sh_lhs_expr.Name
                                                                              name: a_deplib
                                                                            )
                                                                          op: Equal
                                                                          rhs: (word.Empty)
                                                                        )
                                                                      ]
                                                                    )
                                                                  ]
                                                                )
                                                              ]
                                                            )
                                                          ]
                                                        )
                                                      ]
                                                    )
                                                    (command.If
                                                      arms: [
                                                        (if_arm
                                                          cond: [
                                                            (command.Sentence
                                                              child: 
                                                                (C {(test)} {(-n)} 
                                                                  {
                                                                    (DQ 
                                                                      ($ VSub_DollarName '$a_deplib')
                                                                    )
                                                                  }
                                                                )
                                                              terminator: <Op_Semi ';'>
                                                            )
                                                          ]
                                                          action: [
                                                            (command.ShAssignment
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: 
                                                                    (sh_lhs_expr.Name
                                                                      name: libname
                                                                    )
                                                                  op: Equal
                                                                  rhs: 
                                                                    {
                                                                      (command_sub
                                                                        left_token: 
                                                                          <Left_Backtick '`'>
                                                                        command_list: 
                                                                          (command.CommandList
                                                                            children: [
                                                                              (C {(eval)} 
                                                                                {
                                                                                  (DQ 
                                                                                    (word_part.EscapedLiteral
                                                                                      token: 
                                                                                        <
Lit_EscapedChar '\\$'
                                                                                        >
                                                                                    ) ('ECHO ')
                                                                                  ) ($ VSub_DollarName '$libname_spec') (DQ )
                                                                                }
                                                                              )
                                                                            ]
                                                                          )
                                                                      )
                                                                    }
                                                                )
                                                              ]
                                                            )
                                                            (command.ForEach
                                                              iter_name: i
                                                              iter_words: [
                                                                {
                                                                  ($ VSub_DollarName 
'$lib_search_path'
                                                                  )
                                                                }
                                                                {
                                                                  ($ VSub_DollarName 
'$sys_lib_search_path'
                                                                  )
                                                                }
                                                                {
                                                                  ($ VSub_DollarName 
'$shlib_search_path'
                                                                  )
                                                                }
                                                              ]
                                                              do_arg_iter: F
                                                              body: 
                                                                (command.DoGroup
                                                                  children: [
                                                                    (command.ShAssignment
                                                                      pairs: [
                                                                        (assign_pair
                                                                          lhs: 
                                                                            (sh_lhs_expr.Name
                                                                              name: potential_libs
                                                                            )
                                                                          op: Equal
                                                                          rhs: 
                                                                            {
                                                                              (command_sub
                                                                                left_token: 
                                                                                  <Left_Backtick '`'>
                                                                                command_list: 
                                                                                  (command.CommandList
                                                                                    children: [
                                                                                      (command.Simple
                                                                                        words: [
                                                                                          {(ls)}
                                                                                          {
                                                                                            ($ 
VSub_DollarName '$i'
                                                                                            ) (/) ($ VSub_DollarName '$libname') (Lit_LBracket '[') (.-) (Lit_RBracket ']') (Lit_Star '*')
                                                                                          }
                                                                                        ]
                                                                                        redirects: [
                                                                                          (redir.Redir
                                                                                            op: 
                                                                                              <
Redir_Great '2>'
                                                                                              >
                                                                                            fd: 2
                                                                                            arg_word: 
                                                                                              {
                                                                                                (
/dev/null
                                                                                                )
                                                                                              }
                                                                                          )
                                                                                        ]
                                                                                      )
                                                                                    ]
                                                                                  )
                                                                              )
                                                                            }
                                                                        )
                                                                      ]
                                                                    )
                                                                    (command.ForEach
                                                                      iter_name: potent_lib
                                                                      iter_words: [
                                                                        {
                                                                          ($ VSub_DollarName 
'$potential_libs'
                                                                          )
                                                                        }
                                                                      ]
                                                                      do_arg_iter: F
                                                                      body: 
                                                                        (command.DoGroup
                                                                          children: [
                                                                            (command.ShAssignment
                                                                              pairs: [
                                                                                (assign_pair
                                                                                  lhs: 
                                                                                    (sh_lhs_expr.Name
                                                                                      name: potlib
                                                                                    )
                                                                                  op: Equal
                                                                                  rhs: 
                                                                                    {
                                                                                      ($ 
VSub_DollarName '$potent_lib'
                                                                                      )
                                                                                    }
                                                                                )
                                                                              ]
                                                                            )
                                                                            (command.If
                                                                              arms: [
                                                                                (if_arm
                                                                                  cond: [
                                                                                    (command.Sentence
                                                                                      child: 
                                                                                        (command.Pipeline
                                                                                          children: [
                                                                                            (command.Simple
                                                                                              words: [
                                                                                                {
                                                                                                  (
eval
                                                                                                  )
                                                                                                }
                                                                                                {
                                                                                                  (DQ 
                                                                                                    (word_part.EscapedLiteral
                                                                                                      token: 
                                                                                                        <
Lit_EscapedChar '\\$'
                                                                                                        >
                                                                                                    ) ('ECHO ') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) ($ VSub_DollarName '$potent_lib') 
                                                                                                    (word_part.EscapedLiteral
                                                                                                      token: 
                                                                                                        <
Lit_EscapedChar '\\"'
                                                                                                        >
                                                                                                    )
                                                                                                  )
                                                                                                }
                                                                                              ]
                                                                                              redirects: [
                                                                                                (redir.Redir
                                                                                                  op: 
                                                                                                    <
Redir_Great '2>'
                                                                                                    >
                                                                                                  fd: 
2
                                                                                                  arg_word: 
                                                                                                    {
                                                                                                      (
/dev/null
                                                                                                      )
                                                                                                    }
                                                                                                )
                                                                                              ]
                                                                                            )
                                                                                            (C 
                                                                                              {
                                                                                                ($ 
VSub_DollarName '$SED'
                                                                                                )
                                                                                              } {(10q)}
                                                                                            )
                                                                                            (command.Simple
                                                                                              words: [
                                                                                                {
                                                                                                  ($ 
VSub_DollarName '$EGREP'
                                                                                                  )
                                                                                                }
                                                                                                {
                                                                                                  (DQ 
                                                                                                    ($ 
VSub_DollarName '$match_pattern_regex'
                                                                                                    )
                                                                                                  )
                                                                                                }
                                                                                              ]
                                                                                              redirects: [
                                                                                                (redir.Redir
                                                                                                  op: 
                                                                                                    <
Redir_Great '>'
                                                                                                    >
                                                                                                  fd: 
16777215
                                                                                                  arg_word: 
                                                                                                    {
                                                                                                      (
/dev/null
                                                                                                      )
                                                                                                    }
                                                                                                )
                                                                                              ]
                                                                                            )
                                                                                          ]
                                                                                          negated: F
                                                                                        )
                                                                                      terminator: 
                                                                                        <Op_Semi ';'>
                                                                                    )
                                                                                  ]
                                                                                  action: [
                                                                                    (C {(func_append)} 
                                                                                      {(newdeplibs)} {(DQ (' ') ($ VSub_DollarName '$a_deplib'))}
                                                                                    )
                                                                                    (command.ShAssignment
                                                                                      pairs: [
                                                                                        (assign_pair
                                                                                          lhs: 
                                                                                            (sh_lhs_expr.Name
                                                                                              name: 
a_deplib
                                                                                            )
                                                                                          op: Equal
                                                                                          rhs: (word.Empty)
                                                                                        )
                                                                                      ]
                                                                                    )
                                                                                    (command.ControlFlow
                                                                                      token: 
                                                                                        <
ControlFlow_Break break
                                                                                        >
                                                                                      arg_word: {(2)}
                                                                                    )
                                                                                  ]
                                                                                )
                                                                              ]
                                                                            )
                                                                          ]
                                                                        )
                                                                    )
                                                                  ]
                                                                )
                                                            )
                                                          ]
                                                        )
                                                      ]
                                                    )
                                                    (command.If
                                                      arms: [
                                                        (if_arm
                                                          cond: [
                                                            (command.Sentence
                                                              child: 
                                                                (C {(test)} {(-n)} 
                                                                  {
                                                                    (DQ 
                                                                      ($ VSub_DollarName '$a_deplib')
                                                                    )
                                                                  }
                                                                )
                                                              terminator: <Op_Semi ';'>
                                                            )
                                                          ]
                                                          action: [
                                                            (command.ShAssignment
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: 
                                                                    (sh_lhs_expr.Name
                                                                      name: droppeddeps
                                                                    )
                                                                  op: Equal
                                                                  rhs: {(yes)}
                                                                )
                                                              ]
                                                            )
                                                            (C {(echo)})
                                                            (C {($ VSub_DollarName '$ECHO')} 
                                                              {
                                                                (DQ 
                                                                  (
'*** Warning: linker path does not have real file for library '
                                                                  ) ($ VSub_DollarName '$a_deplib') (.)
                                                                )
                                                              }
                                                            )
                                                            (C {(echo)} 
                                                              {
                                                                (DQ 
                                                                  (
'*** I have the capability to make that library automatically link in when'
                                                                  )
                                                                )
                                                              }
                                                            )
                                                            (C {(echo)} 
                                                              {
                                                                (DQ 
                                                                  (
'*** you link to this library.  But I can only do this if you have a'
                                                                  )
                                                                )
                                                              }
                                                            )
                                                            (C {(echo)} 
                                                              {
                                                                (DQ 
                                                                  (
'*** shared version of the library, which you do not appear to have'
                                                                  )
                                                                )
                                                              }
                                                            )
                                                            (C {(echo)} 
                                                              {
                                                                (DQ 
                                                                  (
'*** because I did check the linker path looking for a file starting'
                                                                  )
                                                                )
                                                              }
                                                            )
                                                            (command.If
                                                              arms: [
                                                                (if_arm
                                                                  cond: [
                                                                    (command.Sentence
                                                                      child: 
                                                                        (C {(test)} {(-z)} 
                                                                          {
                                                                            (DQ 
                                                                              ($ VSub_DollarName 
'$potlib'
                                                                              )
                                                                            )
                                                                          }
                                                                        )
                                                                      terminator: <Op_Semi ';'>
                                                                    )
                                                                  ]
                                                                  action: [
                                                                    (C {($ VSub_DollarName '$ECHO')} 
                                                                      {
                                                                        (DQ ('*** with ') 
                                                                          ($ VSub_DollarName 
'$libname'
                                                                          ) (' but no candidates were found. (...for regex pattern test)')
                                                                        )
                                                                      }
                                                                    )
                                                                  ]
                                                                )
                                                              ]
                                                              else_action: [
                                                                (C {($ VSub_DollarName '$ECHO')} 
                                                                  {
                                                                    (DQ ('*** with ') 
                                                                      ($ VSub_DollarName '$libname') (' and none of the candidates passed a file format test')
                                                                    )
                                                                  }
                                                                )
                                                                (C {($ VSub_DollarName '$ECHO')} 
                                                                  {
                                                                    (DQ 
                                                                      (
'*** using a regex pattern. Last file checked: '
                                                                      ) ($ VSub_DollarName '$potlib')
                                                                    )
                                                                  }
                                                                )
                                                              ]
                                                            )
                                                          ]
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                )
                                                (case_arm
                                                  pat_list: [{(Lit_Star '*')}]
                                                  action: [
                                                    (C {(func_append)} {(newdeplibs)} 
                                                      {(DQ (' ') ($ VSub_DollarName '$a_deplib'))}
                                                    )
                                                  ]
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                    )
                                  ]
                                )
                                (case_arm
                                  pat_list: [{(none)} {(unknown)} {(Lit_Star '*')}]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:newdeplibs)
                                          op: Equal
                                          rhs: (word.Empty)
                                        )
                                      ]
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:tmp_deplibs)
                                          op: Equal
                                          rhs: 
                                            {
                                              (command_sub
                                                left_token: <Left_Backtick '`'>
                                                command_list: 
                                                  (command.CommandList
                                                    children: [
                                                      (command.Pipeline
                                                        children: [
                                                          (C {($ VSub_DollarName '$ECHO')} 
                                                            {
                                                              (DQ (' ') ($ VSub_DollarName '$deplibs'))
                                                            }
                                                          )
                                                          (C {($ VSub_DollarName '$SED')} 
                                                            {(SQ <'s/ -lc$//; s/ -[LR][^ ]*//g'>)}
                                                          )
                                                        ]
                                                        negated: F
                                                      )
                                                    ]
                                                  )
                                              )
                                            }
                                        )
                                      ]
                                    )
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (command.Sentence
                                              child: 
                                                (C {(test)} {(yes)} {(Lit_Equals '=')} 
                                                  {
                                                    (DQ 
                                                      ($ VSub_DollarName 
'$allow_libtool_libs_with_static_runtimes'
                                                      )
                                                    )
                                                  }
                                                )
                                              terminator: <Op_Semi ';'>
                                            )
                                          ]
                                          action: [
                                            (command.ForEach
                                              iter_name: i
                                              iter_words: [
                                                {($ VSub_DollarName '$predeps')}
                                                {($ VSub_DollarName '$postdeps')}
                                              ]
                                              do_arg_iter: F
                                              body: 
                                                (command.DoGroup
                                                  children: [
                                                    (command.ShAssignment
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (sh_lhs_expr.Name name:tmp_deplibs)
                                                          op: Equal
                                                          rhs: 
                                                            {
                                                              (command_sub
                                                                left_token: <Left_Backtick '`'>
                                                                command_list: 
                                                                  (command.CommandList
                                                                    children: [
                                                                      (command.Pipeline
                                                                        children: [
                                                                          (C 
                                                                            {
                                                                              ($ VSub_DollarName 
'$ECHO'
                                                                              )
                                                                            } {(DQ (' ') ($ VSub_DollarName '$tmp_deplibs'))}
                                                                          )
                                                                          (C 
                                                                            {
                                                                              ($ VSub_DollarName 
'$SED'
                                                                              )
                                                                            } {(DQ ('s|') ($ VSub_DollarName '$i') ('||'))}
                                                                          )
                                                                        ]
                                                                        negated: F
                                                                      )
                                                                    ]
                                                                  )
                                                              )
                                                            }
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                )
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                    (command.Case
                                      to_match: {($ VSub_DollarName '$tmp_deplibs')}
                                      arms: [
                                        (case_arm
                                          pat_list: [
                                            {(Lit_Star '*') (Lit_LBracket '[') (KW_Bang '!') 
                                              (word_part.EscapedLiteral
                                                token: <Lit_EscapedChar '\\\t'>
                                              ) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\ '>) (Lit_RBracket ']') (Lit_Star '*')
                                            }
                                          ]
                                          action: [
                                            (C {(echo)})
                                            (command.If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (command.Sentence
                                                      child: 
                                                        (C {(test)} {(none)} {(Lit_Equals '=')} 
                                                          {
                                                            (DQ 
                                                              ($ VSub_DollarName 
'$deplibs_check_method'
                                                              )
                                                            )
                                                          }
                                                        )
                                                      terminator: <Op_Semi ';'>
                                                    )
                                                  ]
                                                  action: [
                                                    (C {(echo)} 
                                                      {
                                                        (DQ 
                                                          (
'*** Warning: inter-library dependencies are not supported in this platform.'
                                                          )
                                                        )
                                                      }
                                                    )
                                                  ]
                                                )
                                              ]
                                              else_action: [
                                                (C {(echo)} 
                                                  {
                                                    (DQ 
                                                      (
'*** Warning: inter-library dependencies are not known to be supported.'
                                                      )
                                                    )
                                                  }
                                                )
                                              ]
                                            )
                                            (C {(echo)} 
                                              {
                                                (DQ 
                                                  (
'*** All declared inter-library dependencies are being dropped.'
                                                  )
                                                )
                                              }
                                            )
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:droppeddeps)
                                                  op: Equal
                                                  rhs: {(yes)}
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:versuffix)
                                  op: Equal
                                  rhs: {($ VSub_DollarName '$versuffix_save')}
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:major)
                                  op: Equal
                                  rhs: {($ VSub_DollarName '$major_save')}
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:release)
                                  op: Equal
                                  rhs: {($ VSub_DollarName '$release_save')}
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:libname)
                                  op: Equal
                                  rhs: {($ VSub_DollarName '$libname_save')}
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:name)
                                  op: Equal
                                  rhs: {($ VSub_DollarName '$name_save')}
                                )
                              ]
                            )
                            (command.Case
                              to_match: {($ VSub_DollarName '$host')}
                              arms: [
                                (case_arm
                                  pat_list: [
                                    {(Lit_Star '*') (-) (Lit_Star '*') (-rhapsody) (Lit_Star '*')}
                                    {(Lit_Star '*') (-) (Lit_Star '*') (-darwin1.) (Lit_LBracket '[') 
                                      (012) (Lit_RBracket ']')
                                    }
                                  ]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:newdeplibs)
                                          op: Equal
                                          rhs: 
                                            {
                                              (command_sub
                                                left_token: <Left_Backtick '`'>
                                                command_list: 
                                                  (command.CommandList
                                                    children: [
                                                      (command.Pipeline
                                                        children: [
                                                          (C {($ VSub_DollarName '$ECHO')} 
                                                            {
                                                              (DQ (' ') 
                                                                ($ VSub_DollarName '$newdeplibs')
                                                              )
                                                            }
                                                          )
                                                          (C {($ VSub_DollarName '$SED')} 
                                                            {(SQ <'s/ -lc / System.ltframework /'>)}
                                                          )
                                                        ]
                                                        negated: F
                                                      )
                                                    ]
                                                  )
                                              )
                                            }
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (C {(test)} {(yes)} {(Lit_Equals '=')} 
                                          {(DQ ($ VSub_DollarName '$droppeddeps'))}
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (command.Sentence
                                              child: 
                                                (C {(test)} {(yes)} {(Lit_Equals '=')} 
                                                  {(DQ ($ VSub_DollarName '$module'))}
                                                )
                                              terminator: <Op_Semi ';'>
                                            )
                                          ]
                                          action: [
                                            (C {(echo)})
                                            (C {(echo)} 
                                              {
                                                (DQ 
                                                  (
'*** Warning: libtool could not satisfy all declared inter-library'
                                                  )
                                                )
                                              }
                                            )
                                            (C {($ VSub_DollarName '$ECHO')} 
                                              {
                                                (DQ ('*** dependencies of module ') 
                                                  ($ VSub_DollarName '$libname') ('.  Therefore, libtool will create')
                                                )
                                              }
                                            )
                                            (C {(echo)} 
                                              {
                                                (DQ 
                                                  (
'*** a static module, that should work as long as the dlopening'
                                                  )
                                                )
                                              }
                                            )
                                            (C {(echo)} 
                                              {
                                                (DQ 
                                                  (
'*** application is linked with the -dlopen flag.'
                                                  )
                                                )
                                              }
                                            )
                                            (command.If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (command.Sentence
                                                      child: 
                                                        (C {(test)} {(-z)} 
                                                          {
                                                            (DQ 
                                                              ($ VSub_DollarName 
'$global_symbol_pipe'
                                                              )
                                                            )
                                                          }
                                                        )
                                                      terminator: <Op_Semi ';'>
                                                    )
                                                  ]
                                                  action: [
                                                    (C {(echo)})
                                                    (C {(echo)} 
                                                      {
                                                        (DQ 
                                                          (
'*** However, this would only work if libtool was able to extract symbol'
                                                          )
                                                        )
                                                      }
                                                    )
                                                    (C {(echo)} 
                                                      {
                                                        (DQ 
                                                          (
"*** lists from a program, using 'nm' or equivalent, but libtool could"
                                                          )
                                                        )
                                                      }
                                                    )
                                                    (C {(echo)} 
                                                      {
                                                        (DQ 
                                                          (
'*** not find such a program.  So, this module is probably useless.'
                                                          )
                                                        )
                                                      }
                                                    )
                                                    (C {(echo)} 
                                                      {
                                                        (DQ 
                                                          (
"*** 'nm' from GNU binutils and a full rebuild may help."
                                                          )
                                                        )
                                                      }
                                                    )
                                                  ]
                                                )
                                              ]
                                            )
                                            (command.If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (command.Sentence
                                                      child: 
                                                        (C {(test)} {(no)} {(Lit_Equals '=')} 
                                                          {(DQ ($ VSub_DollarName '$build_old_libs'))}
                                                        )
                                                      terminator: <Op_Semi ';'>
                                                    )
                                                  ]
                                                  action: [
                                                    (command.ShAssignment
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (sh_lhs_expr.Name name:oldlibs)
                                                          op: Equal
                                                          rhs: 
                                                            {($ VSub_DollarName '$output_objdir') (/) 
                                                              ($ VSub_DollarName '$libname') (.) ($ VSub_DollarName '$libext')
                                                            }
                                                        )
                                                      ]
                                                    )
                                                    (command.ShAssignment
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: 
                                                            (sh_lhs_expr.Name
                                                              name: build_libtool_libs
                                                            )
                                                          op: Equal
                                                          rhs: {(module)}
                                                        )
                                                      ]
                                                    )
                                                    (command.ShAssignment
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (sh_lhs_expr.Name name:build_old_libs)
                                                          op: Equal
                                                          rhs: {(yes)}
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                )
                                              ]
                                              else_action: [
                                                (command.ShAssignment
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (sh_lhs_expr.Name name:build_libtool_libs)
                                                      op: Equal
                                                      rhs: {(no)}
                                                    )
                                                  ]
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                      ]
                                      else_action: [
                                        (C {(echo)} 
                                          {
                                            (DQ 
                                              (
'*** The inter-library dependencies that have been dropped here will be'
                                              )
                                            )
                                          }
                                        )
                                        (C {(echo)} 
                                          {
                                            (DQ 
                                              (
'*** automatically added whenever a program is linked with this library'
                                              )
                                            )
                                          }
                                        )
                                        (C {(echo)} {(DQ ('*** or is declared to -dlopen it.'))})
                                        (command.If
                                          arms: [
                                            (if_arm
                                              cond: [
                                                (command.Sentence
                                                  child: 
                                                    (C {(test)} {(no)} {(Lit_Equals '=')} 
                                                      {(DQ ($ VSub_DollarName '$allow_undefined'))}
                                                    )
                                                  terminator: <Op_Semi ';'>
                                                )
                                              ]
                                              action: [
                                                (C {(echo)})
                                                (C {(echo)} 
                                                  {
                                                    (DQ 
                                                      (
'*** Since this library must not contain undefined symbols,'
                                                      )
                                                    )
                                                  }
                                                )
                                                (C {(echo)} 
                                                  {
                                                    (DQ 
                                                      (
'*** because either the platform does not support them or'
                                                      )
                                                    )
                                                  }
                                                )
                                                (C {(echo)} 
                                                  {
                                                    (DQ 
                                                      (
'*** it was explicitly requested with -no-undefined,'
                                                      )
                                                    )
                                                  }
                                                )
                                                (C {(echo)} 
                                                  {
                                                    (DQ 
                                                      (
'*** libtool will only create a static version of it.'
                                                      )
                                                    )
                                                  }
                                                )
                                                (command.If
                                                  arms: [
                                                    (if_arm
                                                      cond: [
                                                        (command.Sentence
                                                          child: 
                                                            (C {(test)} {(no)} {(Lit_Equals '=')} 
                                                              {
                                                                (DQ 
                                                                  ($ VSub_DollarName 
'$build_old_libs'
                                                                  )
                                                                )
                                                              }
                                                            )
                                                          terminator: <Op_Semi ';'>
                                                        )
                                                      ]
                                                      action: [
                                                        (command.ShAssignment
                                                          pairs: [
                                                            (assign_pair
                                                              lhs: (sh_lhs_expr.Name name:oldlibs)
                                                              op: Equal
                                                              rhs: 
                                                                {
                                                                  ($ VSub_DollarName '$output_objdir') (/) ($ VSub_DollarName '$libname') (.) ($ VSub_DollarName '$libext')
                                                                }
                                                            )
                                                          ]
                                                        )
                                                        (command.ShAssignment
                                                          pairs: [
                                                            (assign_pair
                                                              lhs: 
                                                                (sh_lhs_expr.Name
                                                                  name: build_libtool_libs
                                                                )
                                                              op: Equal
                                                              rhs: {(module)}
                                                            )
                                                          ]
                                                        )
                                                        (command.ShAssignment
                                                          pairs: [
                                                            (assign_pair
                                                              lhs: 
                                                                (sh_lhs_expr.Name
                                                                  name: build_old_libs
                                                                )
                                                              op: Equal
                                                              rhs: {(yes)}
                                                            )
                                                          ]
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                  else_action: [
                                                    (command.ShAssignment
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: 
                                                            (sh_lhs_expr.Name
                                                              name: build_libtool_libs
                                                            )
                                                          op: Equal
                                                          rhs: {(no)}
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:deplibs)
                                  op: Equal
                                  rhs: {($ VSub_DollarName '$newdeplibs')}
                                )
                              ]
                            )
                          ]
                        )
                      ]
                    )
                    (command.Case
                      to_match: {($ VSub_DollarName '$host')}
                      arms: [
                        (case_arm
                          pat_list: [{(Lit_Star '*') (-) (Lit_Star '*') (-darwin) (Lit_Star '*')}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:newdeplibs)
                                  op: Equal
                                  rhs: 
                                    {
                                      (command_sub
                                        left_token: <Left_Backtick '`'>
                                        command_list: 
                                          (command.CommandList
                                            children: [
                                              (command.Pipeline
                                                children: [
                                                  (C {($ VSub_DollarName '$ECHO')} 
                                                    {(DQ (' ') ($ VSub_DollarName '$newdeplibs'))}
                                                  )
                                                  (C {($ VSub_DollarName '$SED')} 
                                                    {
                                                      (SQ 
                                                        <
's% \\([^ $]*\\).ltframework% -framework \\1%g'
                                                        >
                                                      )
                                                    }
                                                  )
                                                ]
                                                negated: F
                                              )
                                            ]
                                          )
                                      )
                                    }
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:new_inherited_linker_flags)
                                  op: Equal
                                  rhs: 
                                    {
                                      (command_sub
                                        left_token: <Left_Backtick '`'>
                                        command_list: 
                                          (command.CommandList
                                            children: [
                                              (command.Pipeline
                                                children: [
                                                  (C {($ VSub_DollarName '$ECHO')} 
                                                    {
                                                      (DQ (' ') 
                                                        ($ VSub_DollarName 
'$new_inherited_linker_flags'
                                                        )
                                                      )
                                                    }
                                                  )
                                                  (C {($ VSub_DollarName '$SED')} 
                                                    {
                                                      (SQ 
                                                        <
's% \\([^ $]*\\).ltframework% -framework \\1%g'
                                                        >
                                                      )
                                                    }
                                                  )
                                                ]
                                                negated: F
                                              )
                                            ]
                                          )
                                      )
                                    }
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:deplibs)
                                  op: Equal
                                  rhs: 
                                    {
                                      (command_sub
                                        left_token: <Left_Backtick '`'>
                                        command_list: 
                                          (command.CommandList
                                            children: [
                                              (command.Pipeline
                                                children: [
                                                  (C {($ VSub_DollarName '$ECHO')} 
                                                    {(DQ (' ') ($ VSub_DollarName '$deplibs'))}
                                                  )
                                                  (C {($ VSub_DollarName '$SED')} 
                                                    {
                                                      (SQ 
                                                        <
's% \\([^ $]*\\).ltframework% -framework \\1%g'
                                                        >
                                                      )
                                                    }
                                                  )
                                                ]
                                                negated: F
                                              )
                                            ]
                                          )
                                      )
                                    }
                                )
                              ]
                            )
                          ]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:new_libs) op:Equal rhs:(word.Empty))]
                    )
                    (command.ForEach
                      iter_name: path
                      iter_words: [{($ VSub_DollarName '$notinst_path')}]
                      do_arg_iter: F
                      body: 
                        (command.DoGroup
                          children: [
                            (command.Case
                              to_match: {(DQ (' ') ($ VSub_DollarName '$new_libs') (' '))}
                              arms: [
                                (case_arm
                                  pat_list: [
                                    {(Lit_Star '*') 
                                      (DQ (' -L') ($ VSub_DollarName '$path') (/) 
                                        ($ VSub_DollarName '$objdir') (' ')
                                      ) (Lit_Star '*')
                                    }
                                  ]
                                )
                                (case_arm
                                  pat_list: [{(Lit_Star '*')}]
                                  action: [
                                    (command.Case
                                      to_match: {(DQ (' ') ($ VSub_DollarName '$deplibs') (' '))}
                                      arms: [
                                        (case_arm
                                          pat_list: [
                                            {(Lit_Star '*') 
                                              (DQ (' -L') ($ VSub_DollarName '$path') (/) 
                                                ($ VSub_DollarName '$objdir') (' ')
                                              ) (Lit_Star '*')
                                            }
                                          ]
                                          action: [
                                            (C {(func_append)} {(new_libs)} 
                                              {
                                                (DQ (' -L') ($ VSub_DollarName '$path') (/) 
                                                  ($ VSub_DollarName '$objdir')
                                                )
                                              }
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                            )
                          ]
                        )
                    )
                    (command.ForEach
                      iter_name: deplib
                      iter_words: [{($ VSub_DollarName '$deplibs')}]
                      do_arg_iter: F
                      body: 
                        (command.DoGroup
                          children: [
                            (command.Case
                              to_match: {($ VSub_DollarName '$deplib')}
                              arms: [
                                (case_arm
                                  pat_list: [{(-L) (Lit_Star '*')}]
                                  action: [
                                    (command.Case
                                      to_match: {(DQ (' ') ($ VSub_DollarName '$new_libs') (' '))}
                                      arms: [
                                        (case_arm
                                          pat_list: [
                                            {(Lit_Star '*') 
                                              (DQ (' ') ($ VSub_DollarName '$deplib') (' ')) (Lit_Star '*')
                                            }
                                          ]
                                        )
                                        (case_arm
                                          pat_list: [{(Lit_Star '*')}]
                                          action: [
                                            (C {(func_append)} {(new_libs)} 
                                              {(DQ (' ') ($ VSub_DollarName '$deplib'))}
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                  ]
                                )
                                (case_arm
                                  pat_list: [{(Lit_Star '*')}]
                                  action: [
                                    (C {(func_append)} {(new_libs)} 
                                      {(DQ (' ') ($ VSub_DollarName '$deplib'))}
                                    )
                                  ]
                                )
                              ]
                            )
                          ]
                        )
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:deplibs)
                          op: Equal
                          rhs: {($ VSub_DollarName '$new_libs')}
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:library_names) op:Equal rhs:(word.Empty))]
                    )
                    (command.ShAssignment
                      pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:old_library) op:Equal rhs:(word.Empty))]
                    )
                    (command.ShAssignment
                      pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:dlname) op:Equal rhs:(word.Empty))]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: 
                                (C {(test)} {(yes)} {(Lit_Equals '=')} 
                                  {(DQ ($ VSub_DollarName '$build_libtool_libs'))}
                                )
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [
                            (command.Case
                              to_match: {($ VSub_DollarName '$archive_cmds')}
                              arms: [
                                (case_arm
                                  pat_list: [
                                    {(Lit_Star '*') 
                                      (word_part.EscapedLiteral
                                        token: <Lit_EscapedChar '\\$'>
                                      ) (LD) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\ '>) (Lit_Star '*')
                                    }
                                  ]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:wl) op:Equal rhs:(word.Empty))]
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (C {(test)} {(yes)} {(Lit_Equals '=')} 
                                          {(DQ ($ VSub_DollarName '$hardcode_into_libs'))}
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:hardcode_libdirs)
                                          op: Equal
                                          rhs: (word.Empty)
                                        )
                                      ]
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:dep_rpath)
                                          op: Equal
                                          rhs: (word.Empty)
                                        )
                                      ]
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:rpath)
                                          op: Equal
                                          rhs: {($ VSub_DollarName '$finalize_rpath')}
                                        )
                                      ]
                                    )
                                    (command.AndOr
                                      ops: [Op_DPipe]
                                      children: [
                                        (C {(test)} {(relink)} {(Lit_Equals '=')} 
                                          {(DQ ($ VSub_DollarName '$opt_mode'))}
                                        )
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:rpath)
                                              op: Equal
                                              rhs: 
                                                {($ VSub_DollarName '$compile_rpath') 
                                                  ($ VSub_DollarName '$rpath')
                                                }
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                    (command.ForEach
                                      iter_name: libdir
                                      iter_words: [{($ VSub_DollarName '$rpath')}]
                                      do_arg_iter: F
                                      body: 
                                        (command.DoGroup
                                          children: [
                                            (command.If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (command.Sentence
                                                      child: 
                                                        (C {(test)} {(-n)} 
                                                          {
                                                            (DQ 
                                                              ($ VSub_DollarName 
'$hardcode_libdir_flag_spec'
                                                              )
                                                            )
                                                          }
                                                        )
                                                      terminator: <Op_Semi ';'>
                                                    )
                                                  ]
                                                  action: [
                                                    (command.If
                                                      arms: [
                                                        (if_arm
                                                          cond: [
                                                            (command.Sentence
                                                              child: 
                                                                (C {(test)} {(-n)} 
                                                                  {
                                                                    (DQ 
                                                                      ($ VSub_DollarName 
'$hardcode_libdir_separator'
                                                                      )
                                                                    )
                                                                  }
                                                                )
                                                              terminator: <Op_Semi ';'>
                                                            )
                                                          ]
                                                          action: [
                                                            (C {(func_replace_sysroot)} 
                                                              {(DQ ($ VSub_DollarName '$libdir'))}
                                                            )
                                                            (command.ShAssignment
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: (sh_lhs_expr.Name name:libdir)
                                                                  op: Equal
                                                                  rhs: 
                                                                    {
                                                                      ($ VSub_DollarName 
'$func_replace_sysroot_result'
                                                                      )
                                                                    }
                                                                )
                                                              ]
                                                            )
                                                            (command.If
                                                              arms: [
                                                                (if_arm
                                                                  cond: [
                                                                    (command.Sentence
                                                                      child: 
                                                                        (C {(test)} {(-z)} 
                                                                          {
                                                                            (DQ 
                                                                              ($ VSub_DollarName 
'$hardcode_libdirs'
                                                                              )
                                                                            )
                                                                          }
                                                                        )
                                                                      terminator: <Op_Semi ';'>
                                                                    )
                                                                  ]
                                                                  action: [
                                                                    (command.ShAssignment
                                                                      pairs: [
                                                                        (assign_pair
                                                                          lhs: 
                                                                            (sh_lhs_expr.Name
                                                                              name: hardcode_libdirs
                                                                            )
                                                                          op: Equal
                                                                          rhs: 
                                                                            {
                                                                              ($ VSub_DollarName 
'$libdir'
                                                                              )
                                                                            }
                                                                        )
                                                                      ]
                                                                    )
                                                                  ]
                                                                )
                                                              ]
                                                              else_action: [
                                                                (command.Case
                                                                  to_match: 
                                                                    {
                                                                      ($ VSub_DollarName 
'$hardcode_libdir_separator'
                                                                      ) ($ VSub_DollarName '$hardcode_libdirs') ($ VSub_DollarName '$hardcode_libdir_separator')
                                                                    }
                                                                  arms: [
                                                                    (case_arm
                                                                      pat_list: [
                                                                        {(Lit_Star '*') 
                                                                          (DQ 
                                                                            ($ VSub_DollarName 
'$hardcode_libdir_separator'
                                                                            ) ($ VSub_DollarName '$libdir') ($ VSub_DollarName '$hardcode_libdir_separator')
                                                                          ) (Lit_Star '*')
                                                                        }
                                                                      ]
                                                                    )
                                                                    (case_arm
                                                                      pat_list: [{(Lit_Star '*')}]
                                                                      action: [
                                                                        (C {(func_append)} 
                                                                          {(hardcode_libdirs)} {(DQ ($ VSub_DollarName '$hardcode_libdir_separator') ($ VSub_DollarName '$libdir'))}
                                                                        )
                                                                      ]
                                                                    )
                                                                  ]
                                                                )
                                                              ]
                                                            )
                                                          ]
                                                        )
                                                      ]
                                                      else_action: [
                                                        (C {(eval)} 
                                                          {(Lit_VarLike 'flag=') 
                                                            (word_part.EscapedLiteral
                                                              token: <Lit_EscapedChar '\\"'>
                                                            ) ($ VSub_DollarName '$hardcode_libdir_flag_spec') 
                                                            (word_part.EscapedLiteral
                                                              token: <Lit_EscapedChar '\\"'>
                                                            )
                                                          }
                                                        )
                                                        (C {(func_append)} {(dep_rpath)} 
                                                          {(DQ (' ') ($ VSub_DollarName '$flag'))}
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                )
                                                (if_arm
                                                  cond: [
                                                    (command.Sentence
                                                      child: 
                                                        (C {(test)} {(-n)} 
                                                          {(DQ ($ VSub_DollarName '$runpath_var'))}
                                                        )
                                                      terminator: <Op_Semi ';'>
                                                    )
                                                  ]
                                                  action: [
                                                    (command.Case
                                                      to_match: 
                                                        {(DQ ($ VSub_DollarName '$perm_rpath') (' '))}
                                                      arms: [
                                                        (case_arm
                                                          pat_list: [
                                                            {(Lit_Star '*') 
                                                              (DQ (' ') ($ VSub_DollarName '$libdir') 
                                                                (' ')
                                                              ) (Lit_Star '*')
                                                            }
                                                          ]
                                                        )
                                                        (case_arm
                                                          pat_list: [{(Lit_Star '*')}]
                                                          action: [
                                                            (C {(func_append)} {(perm_rpath)} 
                                                              {
                                                                (DQ (' ') 
                                                                  ($ VSub_DollarName '$libdir')
                                                                )
                                                              }
                                                            )
                                                          ]
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                    )
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (command.Sentence
                                              child: 
                                                (command.AndOr
                                                  ops: [Op_DAmp]
                                                  children: [
                                                    (C {(test)} {(-n)} 
                                                      {
                                                        (DQ 
                                                          ($ VSub_DollarName 
'$hardcode_libdir_separator'
                                                          )
                                                        )
                                                      }
                                                    )
                                                    (C {(test)} {(-n)} 
                                                      {(DQ ($ VSub_DollarName '$hardcode_libdirs'))}
                                                    )
                                                  ]
                                                )
                                              terminator: <Op_Semi ';'>
                                            )
                                          ]
                                          action: [
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:libdir)
                                                  op: Equal
                                                  rhs: {($ VSub_DollarName '$hardcode_libdirs')}
                                                )
                                              ]
                                            )
                                            (C {(eval)} 
                                              {
                                                (DQ ('dep_rpath=') 
                                                  (word_part.EscapedLiteral
                                                    token: <Lit_EscapedChar '\\"'>
                                                  ) ($ VSub_DollarName '$hardcode_libdir_flag_spec') 
                                                  (word_part.EscapedLiteral
                                                    token: <Lit_EscapedChar '\\"'>
                                                  )
                                                )
                                              }
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (command.Sentence
                                              child: 
                                                (command.AndOr
                                                  ops: [Op_DAmp]
                                                  children: [
                                                    (C {(test)} {(-n)} 
                                                      {(DQ ($ VSub_DollarName '$runpath_var'))}
                                                    )
                                                    (C {(test)} {(-n)} 
                                                      {(DQ ($ VSub_DollarName '$perm_rpath'))}
                                                    )
                                                  ]
                                                )
                                              terminator: <Op_Semi ';'>
                                            )
                                          ]
                                          action: [
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:rpath)
                                                  op: Equal
                                                  rhs: (word.Empty)
                                                )
                                              ]
                                            )
                                            (command.ForEach
                                              iter_name: dir
                                              iter_words: [{($ VSub_DollarName '$perm_rpath')}]
                                              do_arg_iter: F
                                              body: 
                                                (command.DoGroup
                                                  children: [
                                                    (C {(func_append)} {(rpath)} 
                                                      {(DQ ($ VSub_DollarName '$dir') (':'))}
                                                    )
                                                  ]
                                                )
                                            )
                                            (C {(eval)} 
                                              {
                                                (DQ ($ VSub_DollarName '$runpath_var') ("='") 
                                                  ($ VSub_DollarName '$rpath') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) ($ VSub_DollarName '$runpath_var') 
                                                  ("'; export ") ($ VSub_DollarName '$runpath_var')
                                                )
                                              }
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                    (command.AndOr
                                      ops: [Op_DAmp]
                                      children: [
                                        (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$dep_rpath'))})
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:deplibs)
                                              op: Equal
                                              rhs: 
                                                {
                                                  (DQ ($ VSub_DollarName '$dep_rpath') (' ') 
                                                    ($ VSub_DollarName '$deplibs')
                                                  )
                                                }
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:shlibpath)
                                  op: Equal
                                  rhs: {($ VSub_DollarName '$finalize_shlibpath')}
                                )
                              ]
                            )
                            (command.AndOr
                              ops: [Op_DPipe]
                              children: [
                                (C {(test)} {(relink)} {(Lit_Equals '=')} 
                                  {(DQ ($ VSub_DollarName '$opt_mode'))}
                                )
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:shlibpath)
                                      op: Equal
                                      rhs: 
                                        {($ VSub_DollarName '$compile_shlibpath') 
                                          ($ VSub_DollarName '$shlibpath')
                                        }
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$shlibpath'))})
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (C {(eval)} 
                                      {
                                        (DQ ($ VSub_DollarName '$shlibpath_var') ("='") 
                                          ($ VSub_DollarName '$shlibpath') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) ($ VSub_DollarName '$shlibpath_var') 
                                          ("'; export ") ($ VSub_DollarName '$shlibpath_var')
                                        )
                                      }
                                    )
                                  ]
                                )
                              ]
                            )
                            (C {(eval)} 
                              {(Lit_VarLike 'shared_ext=') 
                                (word_part.EscapedLiteral
                                  token: <Lit_EscapedChar '\\"'>
                                ) ($ VSub_DollarName '$shrext_cmds') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>)
                              }
                            )
                            (C {(eval)} 
                              {(Lit_VarLike 'library_names=') 
                                (word_part.EscapedLiteral
                                  token: <Lit_EscapedChar '\\"'>
                                ) ($ VSub_DollarName '$library_names_spec') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>)
                              }
                            )
                            (C {(KW_Set set)} {(dummy)} {($ VSub_DollarName '$library_names')})
                            (C {(shift)})
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:realname)
                                  op: Equal
                                  rhs: {($ VSub_Number '$1')}
                                )
                              ]
                            )
                            (C {(shift)})
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$soname_spec'))})
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (C {(eval)} 
                                      {(Lit_VarLike 'soname=') 
                                        (word_part.EscapedLiteral
                                          token: <Lit_EscapedChar '\\"'>
                                        ) ($ VSub_DollarName '$soname_spec') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>)
                                      }
                                    )
                                  ]
                                )
                              ]
                              else_action: [
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:soname)
                                      op: Equal
                                      rhs: {($ VSub_DollarName '$realname')}
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: (C {(test)} {(-z)} {(DQ ($ VSub_DollarName '$dlname'))})
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:dlname)
                                          op: Equal
                                          rhs: {($ VSub_DollarName '$soname')}
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:lib)
                                  op: Equal
                                  rhs: 
                                    {($ VSub_DollarName '$output_objdir') (/) 
                                      ($ VSub_DollarName '$realname')
                                    }
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:linknames) op:Equal rhs:(word.Empty))]
                            )
                            (command.ForEach
                              iter_name: link
                              do_arg_iter: T
                              body: 
                                (command.DoGroup
                                  children: [
                                    (C {(func_append)} {(linknames)} 
                                      {(DQ (' ') ($ VSub_DollarName '$link'))}
                                    )
                                  ]
                                )
                            )
                            (command.AndOr
                              ops: [Op_DAmp]
                              children: [
                                (C {(test)} {(-z)} {(DQ ($ VSub_DollarName '$pic_flag'))})
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:libobjs)
                                      op: Equal
                                      rhs: 
                                        {
                                          (command_sub
                                            left_token: <Left_Backtick '`'>
                                            command_list: 
                                              (command.CommandList
                                                children: [
                                                  (command.Pipeline
                                                    children: [
                                                      (C {($ VSub_DollarName '$ECHO')} 
                                                        {(DQ ($ VSub_DollarName '$libobjs'))}
                                                      )
                                                      (C {($ VSub_DollarName '$SP2NL')})
                                                      (C {($ VSub_DollarName '$SED')} 
                                                        {(DQ ($ VSub_DollarName '$lo2o'))}
                                                      )
                                                      (C {($ VSub_DollarName '$NL2SP')})
                                                    ]
                                                    negated: F
                                                  )
                                                ]
                                              )
                                          )
                                        }
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.AndOr
                              ops: [Op_DAmp]
                              children: [
                                (C {(test)} {(DQ (X) ($ VSub_DollarName '$libobjs'))} {(Lit_Equals '=')} 
                                  {(DQ ('X '))}
                                )
                                (command.ShAssignment
                                  pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:libobjs) op:Equal rhs:(word.Empty))]
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:delfiles) op:Equal rhs:(word.Empty))]
                            )
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (command.AndOr
                                          ops: [Op_DAmp]
                                          children: [
                                            (C {(test)} {(-n)} 
                                              {(DQ ($ VSub_DollarName '$export_symbols'))}
                                            )
                                            (C {(test)} {(-n)} 
                                              {(DQ ($ VSub_DollarName '$include_expsyms'))}
                                            )
                                          ]
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (command.AndOr
                                      ops: [Op_DPipe]
                                      children: [
                                        (C {($ VSub_DollarName '$opt_dry_run')})
                                        (C {(cp)} {(DQ ($ VSub_DollarName '$export_symbols'))} 
                                          {
                                            (DQ ($ VSub_DollarName '$output_objdir') (/) 
                                              ($ VSub_DollarName '$libname') (.uexp)
                                            )
                                          }
                                        )
                                      ]
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:export_symbols)
                                          op: Equal
                                          rhs: 
                                            {($ VSub_DollarName '$output_objdir') (/) 
                                              ($ VSub_DollarName '$libname') (.uexp)
                                            }
                                        )
                                      ]
                                    )
                                    (C {(func_append)} {(delfiles)} 
                                      {(DQ (' ') ($ VSub_DollarName '$export_symbols'))}
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:orig_export_symbols)
                                  op: Equal
                                  rhs: (word.Empty)
                                )
                              ]
                            )
                            (command.Case
                              to_match: {($ VSub_DollarName '$host_os')}
                              arms: [
                                (case_arm
                                  pat_list: [
                                    {(cygwin) (Lit_Star '*')}
                                    {(mingw) (Lit_Star '*')}
                                    {(cegcc) (Lit_Star '*')}
                                  ]
                                  action: [
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (command.Sentence
                                              child: 
                                                (command.AndOr
                                                  ops: [Op_DAmp]
                                                  children: [
                                                    (C {(test)} {(-n)} 
                                                      {(DQ ($ VSub_DollarName '$export_symbols'))}
                                                    )
                                                    (C {(test)} {(-z)} 
                                                      {
                                                        (DQ 
                                                          ($ VSub_DollarName '$export_symbols_regex')
                                                        )
                                                      }
                                                    )
                                                  ]
                                                )
                                              terminator: <Op_Semi ';'>
                                            )
                                          ]
                                          action: [
                                            (command.AndOr
                                              ops: [Op_DPipe]
                                              children: [
                                                (C {(func_dll_def_p)} 
                                                  {(DQ ($ VSub_DollarName '$export_symbols'))}
                                                )
                                                (command.BraceGroup
                                                  children: [
                                                    (command.ShAssignment
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: 
                                                            (sh_lhs_expr.Name
                                                              name: orig_export_symbols
                                                            )
                                                          op: Equal
                                                          rhs: {($ VSub_DollarName '$export_symbols')}
                                                        )
                                                      ]
                                                    )
                                                    (command.ShAssignment
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (sh_lhs_expr.Name name:export_symbols)
                                                          op: Equal
                                                          rhs: (word.Empty)
                                                        )
                                                      ]
                                                    )
                                                    (command.ShAssignment
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: 
                                                            (sh_lhs_expr.Name
                                                              name: always_export_symbols
                                                            )
                                                          op: Equal
                                                          rhs: {(yes)}
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (C {(test)} {(-z)} {(DQ ($ VSub_DollarName '$export_symbols'))})
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (command.Sentence
                                              child: 
                                                (command.AndOr
                                                  ops: [Op_DPipe]
                                                  children: [
                                                    (C {(test)} {(yes)} {(Lit_Equals '=')} 
                                                      {
                                                        (DQ 
                                                          ($ VSub_DollarName '$always_export_symbols')
                                                        )
                                                      }
                                                    )
                                                    (C {(test)} {(-n)} 
                                                      {
                                                        (DQ 
                                                          ($ VSub_DollarName '$export_symbols_regex')
                                                        )
                                                      }
                                                    )
                                                  ]
                                                )
                                              terminator: <Op_Semi ';'>
                                            )
                                          ]
                                          action: [
                                            (C {(func_verbose)} 
                                              {
                                                (DQ ("generating symbol list for '") 
                                                  ($ VSub_DollarName '$libname') (".la'")
                                                )
                                              }
                                            )
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:export_symbols)
                                                  op: Equal
                                                  rhs: 
                                                    {($ VSub_DollarName '$output_objdir') (/) 
                                                      ($ VSub_DollarName '$libname') (.exp)
                                                    }
                                                )
                                              ]
                                            )
                                            (command.AndOr
                                              ops: [Op_DPipe]
                                              children: [
                                                (C {($ VSub_DollarName '$opt_dry_run')})
                                                (C {($ VSub_DollarName '$RM')} 
                                                  {($ VSub_DollarName '$export_symbols')}
                                                )
                                              ]
                                            )
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:cmds)
                                                  op: Equal
                                                  rhs: {($ VSub_DollarName '$export_symbols_cmds')}
                                                )
                                              ]
                                            )
                                            (command.Sentence
                                              child: 
                                                (command.ShAssignment
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (sh_lhs_expr.Name name:save_ifs)
                                                      op: Equal
                                                      rhs: {($ VSub_DollarName '$IFS')}
                                                    )
                                                  ]
                                                )
                                              terminator: <Op_Semi ';'>
                                            )
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:IFS)
                                                  op: Equal
                                                  rhs: {(SQ <'~'>)}
                                                )
                                              ]
                                            )
                                            (command.ForEach
                                              iter_name: cmd1
                                              iter_words: [{($ VSub_DollarName '$cmds')}]
                                              do_arg_iter: F
                                              body: 
                                                (command.DoGroup
                                                  children: [
                                                    (command.ShAssignment
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (sh_lhs_expr.Name name:IFS)
                                                          op: Equal
                                                          rhs: {($ VSub_DollarName '$save_ifs')}
                                                        )
                                                      ]
                                                    )
                                                    (command.Case
                                                      to_match: 
                                                        {($ VSub_DollarName '$nm_file_list_spec') 
                                                          (Lit_TildeLike '~') ($ VSub_DollarName '$to_tool_file_cmd')
                                                        }
                                                      arms: [
                                                        (case_arm
                                                          pat_list: [
                                                            {(Lit_Star '*') 
                                                              (Lit_TildeLike 
'~func_convert_file_noop'
                                                              )
                                                            }
                                                            {(Lit_Star '*') 
                                                              (Lit_TildeLike 
'~func_convert_file_msys_to_w32'
                                                              )
                                                            }
                                                            {(Lit_TildeLike '~') (Lit_Star '*')}
                                                          ]
                                                          action: [
                                                            (command.ShAssignment
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: 
                                                                    (sh_lhs_expr.Name
                                                                      name: try_normal_branch
                                                                    )
                                                                  op: Equal
                                                                  rhs: {(yes)}
                                                                )
                                                              ]
                                                            )
                                                            (C {(eval)} 
                                                              {(Lit_VarLike 'cmd=') 
                                                                (word_part.EscapedLiteral
                                                                  token: <Lit_EscapedChar '\\"'>
                                                                ) ($ VSub_DollarName '$cmd1') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>)
                                                              }
                                                            )
                                                            (C {(func_len)} 
                                                              {(DQ (' ') ($ VSub_DollarName '$cmd'))}
                                                            )
                                                            (command.ShAssignment
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: (sh_lhs_expr.Name name:len)
                                                                  op: Equal
                                                                  rhs: 
                                                                    {
                                                                      ($ VSub_DollarName 
'$func_len_result'
                                                                      )
                                                                    }
                                                                )
                                                              ]
                                                            )
                                                          ]
                                                        )
                                                        (case_arm
                                                          pat_list: [{(Lit_Star '*')}]
                                                          action: [
                                                            (command.ShAssignment
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: 
                                                                    (sh_lhs_expr.Name
                                                                      name: try_normal_branch
                                                                    )
                                                                  op: Equal
                                                                  rhs: {(no)}
                                                                )
                                                              ]
                                                            )
                                                          ]
                                                        )
                                                      ]
                                                    )
                                                    (command.If
                                                      arms: [
                                                        (if_arm
                                                          cond: [
                                                            (command.AndOr
                                                              ops: [Op_DAmp]
                                                              children: [
                                                                (C {(test)} {(yes)} {(Lit_Equals '=')} 
                                                                  {
                                                                    (DQ 
                                                                      ($ VSub_DollarName 
'$try_normal_branch'
                                                                      )
                                                                    )
                                                                  }
                                                                )
                                                                (command.BraceGroup
                                                                  children: [
                                                                    (command.Sentence
                                                                      child: 
                                                                        (command.AndOr
                                                                          ops: [Op_DPipe]
                                                                          children: [
                                                                            (C {(test)} 
                                                                              {
                                                                                (DQ 
                                                                                  ($ VSub_DollarName 
'$len'
                                                                                  )
                                                                                )
                                                                              } {(-lt)} {(DQ ($ VSub_DollarName '$max_cmd_len'))}
                                                                            )
                                                                            (C {(test)} 
                                                                              {
                                                                                (DQ 
                                                                                  ($ VSub_DollarName 
'$max_cmd_len'
                                                                                  )
                                                                                )
                                                                              } {(-le)} {(-1)}
                                                                            )
                                                                          ]
                                                                        )
                                                                      terminator: <Op_Semi ';'>
                                                                    )
                                                                  ]
                                                                )
                                                              ]
                                                            )
                                                          ]
                                                          action: [
                                                            (C {(func_show_eval)} 
                                                              {(DQ ($ VSub_DollarName '$cmd'))} {(SQ <'exit $?'>)}
                                                            )
                                                            (command.ShAssignment
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: 
                                                                    (sh_lhs_expr.Name
                                                                      name: skipped_export
                                                                    )
                                                                  op: Equal
                                                                  rhs: {(false)}
                                                                )
                                                              ]
                                                            )
                                                          ]
                                                        )
                                                        (if_arm
                                                          cond: [
                                                            (command.Sentence
                                                              child: 
                                                                (C {(test)} {(-n)} 
                                                                  {
                                                                    (DQ 
                                                                      ($ VSub_DollarName 
'$nm_file_list_spec'
                                                                      )
                                                                    )
                                                                  }
                                                                )
                                                              terminator: <Op_Semi ';'>
                                                            )
                                                          ]
                                                          action: [
                                                            (C {(func_basename)} 
                                                              {(DQ ($ VSub_DollarName '$output'))}
                                                            )
                                                            (command.ShAssignment
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: 
                                                                    (sh_lhs_expr.Name
                                                                      name: output_la
                                                                    )
                                                                  op: Equal
                                                                  rhs: 
                                                                    {
                                                                      ($ VSub_DollarName 
'$func_basename_result'
                                                                      )
                                                                    }
                                                                )
                                                              ]
                                                            )
                                                            (command.ShAssignment
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: 
                                                                    (sh_lhs_expr.Name
                                                                      name: save_libobjs
                                                                    )
                                                                  op: Equal
                                                                  rhs: 
                                                                    {($ VSub_DollarName '$libobjs')}
                                                                )
                                                              ]
                                                            )
                                                            (command.ShAssignment
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: 
                                                                    (sh_lhs_expr.Name
                                                                      name: save_output
                                                                    )
                                                                  op: Equal
                                                                  rhs: {($ VSub_DollarName '$output')}
                                                                )
                                                              ]
                                                            )
                                                            (command.ShAssignment
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: (sh_lhs_expr.Name name:output)
                                                                  op: Equal
                                                                  rhs: 
                                                                    {
                                                                      ($ VSub_DollarName 
'$output_objdir'
                                                                      ) (/) ($ VSub_DollarName '$output_la') (.nm)
                                                                    }
                                                                )
                                                              ]
                                                            )
                                                            (C {(func_to_tool_file)} 
                                                              {(DQ ($ VSub_DollarName '$output'))}
                                                            )
                                                            (command.ShAssignment
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: 
                                                                    (sh_lhs_expr.Name
                                                                      name: libobjs
                                                                    )
                                                                  op: Equal
                                                                  rhs: 
                                                                    {
                                                                      ($ VSub_DollarName 
'$nm_file_list_spec'
                                                                      ) ($ VSub_DollarName '$func_to_tool_file_result')
                                                                    }
                                                                )
                                                              ]
                                                            )
                                                            (C {(func_append)} {(delfiles)} 
                                                              {
                                                                (DQ (' ') 
                                                                  ($ VSub_DollarName '$output')
                                                                )
                                                              }
                                                            )
                                                            (C {(func_verbose)} 
                                                              {
                                                                (DQ ('creating ') 
                                                                  ($ VSub_DollarName '$NM') (' input file list: ') ($ VSub_DollarName '$output')
                                                                )
                                                              }
                                                            )
                                                            (command.ForEach
                                                              iter_name: obj
                                                              iter_words: [
                                                                {($ VSub_DollarName '$save_libobjs')}
                                                              ]
                                                              do_arg_iter: F
                                                              body: 
                                                                (command.DoGroup
                                                                  children: [
                                                                    (C {(func_to_tool_file)} 
                                                                      {
                                                                        (DQ 
                                                                          ($ VSub_DollarName '$obj')
                                                                        )
                                                                      }
                                                                    )
                                                                    (C {($ VSub_DollarName '$ECHO')} 
                                                                      {
                                                                        (DQ 
                                                                          ($ VSub_DollarName 
'$func_to_tool_file_result'
                                                                          )
                                                                        )
                                                                      }
                                                                    )
                                                                  ]
                                                                )
                                                              redirects: [
                                                                (redir.Redir
                                                                  op: <Redir_Great '>'>
                                                                  fd: 16777215
                                                                  arg_word: 
                                                                    {
                                                                      (DQ 
                                                                        ($ VSub_DollarName '$output')
                                                                      )
                                                                    }
                                                                )
                                                              ]
                                                            )
                                                            (C {(eval)} 
                                                              {(Lit_VarLike 'cmd=') 
                                                                (word_part.EscapedLiteral
                                                                  token: <Lit_EscapedChar '\\"'>
                                                                ) ($ VSub_DollarName '$cmd1') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>)
                                                              }
                                                            )
                                                            (C {(func_show_eval)} 
                                                              {(DQ ($ VSub_DollarName '$cmd'))} {(SQ <'exit $?'>)}
                                                            )
                                                            (command.ShAssignment
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: (sh_lhs_expr.Name name:output)
                                                                  op: Equal
                                                                  rhs: 
                                                                    {
                                                                      ($ VSub_DollarName 
'$save_output'
                                                                      )
                                                                    }
                                                                )
                                                              ]
                                                            )
                                                            (command.ShAssignment
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: 
                                                                    (sh_lhs_expr.Name
                                                                      name: libobjs
                                                                    )
                                                                  op: Equal
                                                                  rhs: 
                                                                    {
                                                                      ($ VSub_DollarName 
'$save_libobjs'
                                                                      )
                                                                    }
                                                                )
                                                              ]
                                                            )
                                                            (command.ShAssignment
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: 
                                                                    (sh_lhs_expr.Name
                                                                      name: skipped_export
                                                                    )
                                                                  op: Equal
                                                                  rhs: {(false)}
                                                                )
                                                              ]
                                                            )
                                                          ]
                                                        )
                                                      ]
                                                      else_action: [
                                                        (C {(func_verbose)} 
                                                          {
                                                            (DQ 
                                                              (
'using reloadable object file for export list...'
                                                              )
                                                            )
                                                          }
                                                        )
                                                        (command.ShAssignment
                                                          pairs: [
                                                            (assign_pair
                                                              lhs: 
                                                                (sh_lhs_expr.Name
                                                                  name: skipped_export
                                                                )
                                                              op: Equal
                                                              rhs: {(Lit_Other ':')}
                                                            )
                                                          ]
                                                        )
                                                        (command.ControlFlow
                                                          token: <ControlFlow_Break break>
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                )
                                            )
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:IFS)
                                                  op: Equal
                                                  rhs: {($ VSub_DollarName '$save_ifs')}
                                                )
                                              ]
                                            )
                                            (command.If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (command.Sentence
                                                      child: 
                                                        (command.AndOr
                                                          ops: [Op_DAmp]
                                                          children: [
                                                            (C {(test)} {(-n)} 
                                                              {
                                                                (DQ 
                                                                  ($ VSub_DollarName 
'$export_symbols_regex'
                                                                  )
                                                                )
                                                              }
                                                            )
                                                            (C {(test)} {(Lit_Other ':')} 
                                                              {(KW_Bang '!') (Lit_Equals '=')} {(DQ ($ VSub_DollarName '$skipped_export'))}
                                                            )
                                                          ]
                                                        )
                                                      terminator: <Op_Semi ';'>
                                                    )
                                                  ]
                                                  action: [
                                                    (C {(func_show_eval)} 
                                                      {
                                                        (SQ 
                                                          <
'$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
                                                          >
                                                        )
                                                      }
                                                    )
                                                    (C {(func_show_eval)} 
                                                      {
                                                        (SQ 
                                                          <
'$MV "${export_symbols}T" "$export_symbols"'
                                                          >
                                                        )
                                                      }
                                                    )
                                                  ]
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (command.AndOr
                                          ops: [Op_DAmp]
                                          children: [
                                            (C {(test)} {(-n)} 
                                              {(DQ ($ VSub_DollarName '$export_symbols'))}
                                            )
                                            (C {(test)} {(-n)} 
                                              {(DQ ($ VSub_DollarName '$include_expsyms'))}
                                            )
                                          ]
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:tmp_export_symbols)
                                          op: Equal
                                          rhs: {($ VSub_DollarName '$export_symbols')}
                                        )
                                      ]
                                    )
                                    (command.AndOr
                                      ops: [Op_DAmp]
                                      children: [
                                        (C {(test)} {(-n)} 
                                          {(DQ ($ VSub_DollarName '$orig_export_symbols'))}
                                        )
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:tmp_export_symbols)
                                              op: Equal
                                              rhs: {($ VSub_DollarName '$orig_export_symbols')}
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                    (command.AndOr
                                      ops: [Op_DPipe]
                                      children: [
                                        (C {($ VSub_DollarName '$opt_dry_run')})
                                        (C {(eval)} 
                                          {
                                            (SQ 
                                              <
'$ECHO "$include_expsyms" | $SP2NL >> "$tmp_export_symbols"'
                                              >
                                            )
                                          }
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (command.AndOr
                                          ops: [Op_DAmp]
                                          children: [
                                            (C {(test)} {(Lit_Other ':')} 
                                              {(KW_Bang '!') (Lit_Equals '=')} {(DQ ($ VSub_DollarName '$skipped_export'))}
                                            )
                                            (C {(test)} {(-n)} 
                                              {(DQ ($ VSub_DollarName '$orig_export_symbols'))}
                                            )
                                          ]
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (C {(func_verbose)} 
                                      {
                                        (DQ ("filter symbol list for '") 
                                          ($ VSub_DollarName '$libname') (".la' to tag DATA exports")
                                        )
                                      }
                                    )
                                    (command.AndOr
                                      ops: [Op_DPipe]
                                      children: [
                                        (C {($ VSub_DollarName '$opt_dry_run')})
                                        (command.Simple
                                          words: [
                                            {($ VSub_DollarName '$SED')}
                                            {(-e)}
                                            {
                                              (SQ 
                                                <
'/[ ,]DATA/!d;s,\\(.*\\)\\([ \\,].*\\),s|^\\1$|\\1\\2|,'
                                                >
                                              )
                                            }
                                          ]
                                          redirects: [
                                            (redir.Redir
                                              op: <Redir_Less '<'>
                                              fd: 16777215
                                              arg_word: {($ VSub_DollarName '$export_symbols')}
                                            )
                                            (redir.Redir
                                              op: <Redir_Great '>'>
                                              fd: 16777215
                                              arg_word: 
                                                {($ VSub_DollarName '$output_objdir') (/) 
                                                  ($ VSub_DollarName '$libname') (.filter)
                                                }
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                    (C {(func_append)} {(delfiles)} 
                                      {
                                        (DQ (' ') ($ VSub_DollarName '$export_symbols') (' ') 
                                          ($ VSub_DollarName '$output_objdir') (/) ($ VSub_DollarName '$libname') (.filter)
                                        )
                                      }
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:export_symbols)
                                          op: Equal
                                          rhs: 
                                            {($ VSub_DollarName '$output_objdir') (/) 
                                              ($ VSub_DollarName '$libname') (.def)
                                            }
                                        )
                                      ]
                                    )
                                    (command.AndOr
                                      ops: [Op_DPipe]
                                      children: [
                                        (C {($ VSub_DollarName '$opt_dry_run')})
                                        (command.Simple
                                          words: [
                                            {($ VSub_DollarName '$SED')}
                                            {(-f)}
                                            {($ VSub_DollarName '$output_objdir') (/) 
                                              ($ VSub_DollarName '$libname') (.filter)
                                            }
                                          ]
                                          redirects: [
                                            (redir.Redir
                                              op: <Redir_Less '<'>
                                              fd: 16777215
                                              arg_word: {($ VSub_DollarName '$orig_export_symbols')}
                                            )
                                            (redir.Redir
                                              op: <Redir_Great '>'>
                                              fd: 16777215
                                              arg_word: {($ VSub_DollarName '$export_symbols')}
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:tmp_deplibs) op:Equal rhs:(word.Empty))]
                            )
                            (command.ForEach
                              iter_name: test_deplib
                              iter_words: [{($ VSub_DollarName '$deplibs')}]
                              do_arg_iter: F
                              body: 
                                (command.DoGroup
                                  children: [
                                    (command.Case
                                      to_match: {(DQ (' ') ($ VSub_DollarName '$convenience') (' '))}
                                      arms: [
                                        (case_arm
                                          pat_list: [
                                            {(Lit_Star '*') 
                                              (DQ (' ') ($ VSub_DollarName '$test_deplib') (' ')) (Lit_Star '*')
                                            }
                                          ]
                                        )
                                        (case_arm
                                          pat_list: [{(Lit_Star '*')}]
                                          action: [
                                            (C {(func_append)} {(tmp_deplibs)} 
                                              {(DQ (' ') ($ VSub_DollarName '$test_deplib'))}
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                  ]
                                )
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:deplibs)
                                  op: Equal
                                  rhs: {($ VSub_DollarName '$tmp_deplibs')}
                                )
                              ]
                            )
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$convenience'))})
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (command.Sentence
                                              child: 
                                                (command.AndOr
                                                  ops: [Op_DAmp Op_DAmp]
                                                  children: [
                                                    (C {(test)} {(-n)} 
                                                      {
                                                        (DQ 
                                                          ($ VSub_DollarName 
'$whole_archive_flag_spec'
                                                          )
                                                        )
                                                      }
                                                    )
                                                    (C {(test)} {(yes)} {(Lit_Equals '=')} 
                                                      {
                                                        (DQ 
                                                          ($ VSub_DollarName '$compiler_needs_object')
                                                        )
                                                      }
                                                    )
                                                    (C {(test)} {(-z)} 
                                                      {(DQ ($ VSub_DollarName '$libobjs'))}
                                                    )
                                                  ]
                                                )
                                              terminator: <Op_Semi ';'>
                                            )
                                          ]
                                          action: [
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: 
                                                    (sh_lhs_expr.Name
                                                      name: whole_archive_flag_spec
                                                    )
                                                  op: Equal
                                                  rhs: (word.Empty)
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (command.Sentence
                                              child: 
                                                (C {(test)} {(-n)} 
                                                  {
                                                    (DQ 
                                                      ($ VSub_DollarName '$whole_archive_flag_spec')
                                                    )
                                                  }
                                                )
                                              terminator: <Op_Semi ';'>
                                            )
                                          ]
                                          action: [
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:save_libobjs)
                                                  op: Equal
                                                  rhs: {($ VSub_DollarName '$libobjs')}
                                                )
                                              ]
                                            )
                                            (C {(eval)} 
                                              {(Lit_VarLike 'libobjs=') 
                                                (word_part.EscapedLiteral
                                                  token: <Lit_EscapedChar '\\"'>
                                                ) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) (libobjs)
                                              } 
                                              {($ VSub_DollarName '$whole_archive_flag_spec') 
                                                (word_part.EscapedLiteral
                                                  token: <Lit_EscapedChar '\\"'>
                                                )
                                              }
                                            )
                                            (command.AndOr
                                              ops: [Op_DAmp]
                                              children: [
                                                (C {(test)} {(DQ (X) ($ VSub_DollarName '$libobjs'))} 
                                                  {(Lit_Equals '=')} {(DQ ('X '))}
                                                )
                                                (command.ShAssignment
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (sh_lhs_expr.Name name:libobjs)
                                                      op: Equal
                                                      rhs: (word.Empty)
                                                    )
                                                  ]
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                      ]
                                      else_action: [
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:gentop)
                                              op: Equal
                                              rhs: 
                                                {($ VSub_DollarName '$output_objdir') (/) 
                                                  (${ VSub_Name outputname) (x)
                                                }
                                            )
                                          ]
                                        )
                                        (C {(func_append)} {(generated)} 
                                          {(DQ (' ') ($ VSub_DollarName '$gentop'))}
                                        )
                                        (C {(func_extract_archives)} {($ VSub_DollarName '$gentop')} 
                                          {($ VSub_DollarName '$convenience')}
                                        )
                                        (C {(func_append)} {(libobjs)} 
                                          {
                                            (DQ (' ') 
                                              ($ VSub_DollarName '$func_extract_archives_result')
                                            )
                                          }
                                        )
                                        (command.AndOr
                                          ops: [Op_DAmp]
                                          children: [
                                            (C {(test)} {(DQ (X) ($ VSub_DollarName '$libobjs'))} 
                                              {(Lit_Equals '=')} {(DQ ('X '))}
                                            )
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:libobjs)
                                                  op: Equal
                                                  rhs: (word.Empty)
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (command.AndOr
                                          ops: [Op_DAmp]
                                          children: [
                                            (C {(test)} {(yes)} {(Lit_Equals '=')} 
                                              {(DQ ($ VSub_DollarName '$thread_safe'))}
                                            )
                                            (C {(test)} {(-n)} 
                                              {(DQ ($ VSub_DollarName '$thread_safe_flag_spec'))}
                                            )
                                          ]
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (C {(eval)} 
                                      {(Lit_VarLike 'flag=') 
                                        (word_part.EscapedLiteral
                                          token: <Lit_EscapedChar '\\"'>
                                        ) ($ VSub_DollarName '$thread_safe_flag_spec') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>)
                                      }
                                    )
                                    (C {(func_append)} {(linker_flags)} 
                                      {(DQ (' ') ($ VSub_DollarName '$flag'))}
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (C {(test)} {(relink)} {(Lit_Equals '=')} 
                                          {(DQ ($ VSub_DollarName '$opt_mode'))}
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (command.AndOr
                                      ops: [Op_DPipe Op_DPipe]
                                      children: [
                                        (C {($ VSub_DollarName '$opt_dry_run')})
                                        (C {(eval)} 
                                          {
                                            (SQ 
                                              <
'(cd $output_objdir && $RM ${realname}U && $MV $realname ${realname}U)'
                                              >
                                            )
                                          }
                                        )
                                        (command.ControlFlow
                                          token: <ControlFlow_Exit exit>
                                          arg_word: {($ VSub_QMark '$?')}
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (command.AndOr
                                          ops: [Op_DAmp]
                                          children: [
                                            (C {(test)} {(yes)} {(Lit_Equals '=')} 
                                              {(DQ ($ VSub_DollarName '$module'))}
                                            )
                                            (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$module_cmds'))})
                                          ]
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (command.Sentence
                                              child: 
                                                (command.AndOr
                                                  ops: [Op_DAmp]
                                                  children: [
                                                    (C {(test)} {(-n)} 
                                                      {(DQ ($ VSub_DollarName '$export_symbols'))}
                                                    )
                                                    (C {(test)} {(-n)} 
                                                      {(DQ ($ VSub_DollarName '$module_expsym_cmds'))}
                                                    )
                                                  ]
                                                )
                                              terminator: <Op_Semi ';'>
                                            )
                                          ]
                                          action: [
                                            (C {(eval)} 
                                              {(Lit_VarLike 'test_cmds=') 
                                                (word_part.EscapedLiteral
                                                  token: <Lit_EscapedChar '\\"'>
                                                ) ($ VSub_DollarName '$module_expsym_cmds') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>)
                                              }
                                            )
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:cmds)
                                                  op: Equal
                                                  rhs: {($ VSub_DollarName '$module_expsym_cmds')}
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                      ]
                                      else_action: [
                                        (C {(eval)} 
                                          {(Lit_VarLike 'test_cmds=') 
                                            (word_part.EscapedLiteral
                                              token: <Lit_EscapedChar '\\"'>
                                            ) ($ VSub_DollarName '$module_cmds') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>)
                                          }
                                        )
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:cmds)
                                              op: Equal
                                              rhs: {($ VSub_DollarName '$module_cmds')}
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                              else_action: [
                                (command.If
                                  arms: [
                                    (if_arm
                                      cond: [
                                        (command.Sentence
                                          child: 
                                            (command.AndOr
                                              ops: [Op_DAmp]
                                              children: [
                                                (C {(test)} {(-n)} 
                                                  {(DQ ($ VSub_DollarName '$export_symbols'))}
                                                )
                                                (C {(test)} {(-n)} 
                                                  {(DQ ($ VSub_DollarName '$archive_expsym_cmds'))}
                                                )
                                              ]
                                            )
                                          terminator: <Op_Semi ';'>
                                        )
                                      ]
                                      action: [
                                        (C {(eval)} 
                                          {(Lit_VarLike 'test_cmds=') 
                                            (word_part.EscapedLiteral
                                              token: <Lit_EscapedChar '\\"'>
                                            ) ($ VSub_DollarName '$archive_expsym_cmds') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>)
                                          }
                                        )
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:cmds)
                                              op: Equal
                                              rhs: {($ VSub_DollarName '$archive_expsym_cmds')}
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                  ]
                                  else_action: [
                                    (C {(eval)} 
                                      {(Lit_VarLike 'test_cmds=') 
                                        (word_part.EscapedLiteral
                                          token: <Lit_EscapedChar '\\"'>
                                        ) ($ VSub_DollarName '$archive_cmds') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>)
                                      }
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:cmds)
                                          op: Equal
                                          rhs: {($ VSub_DollarName '$archive_cmds')}
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (command.AndOr
                                          ops: [Op_DAmp Op_DAmp Op_DAmp Op_DPipe]
                                          children: [
                                            (C {(test)} {(Lit_Other ':')} 
                                              {(KW_Bang '!') (Lit_Equals '=')} {(DQ ($ VSub_DollarName '$skipped_export'))}
                                            )
                                            (C {(func_len)} 
                                              {(DQ (' ') ($ VSub_DollarName '$test_cmds'))}
                                            )
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:len)
                                                  op: Equal
                                                  rhs: {($ VSub_DollarName '$func_len_result')}
                                                )
                                              ]
                                            )
                                            (C {(test)} {(DQ ($ VSub_DollarName '$len'))} {(-lt)} 
                                              {(DQ ($ VSub_DollarName '$max_cmd_len'))}
                                            )
                                            (C {(test)} {(DQ ($ VSub_DollarName '$max_cmd_len'))} 
                                              {(-le)} {(-1)}
                                            )
                                          ]
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [(C {(Lit_Other ':')})]
                                )
                              ]
                              else_action: [
                                (command.If
                                  arms: [
                                    (if_arm
                                      cond: [
                                        (command.Sentence
                                          child: 
                                            (command.AndOr
                                              ops: [Op_DPipe]
                                              children: [
                                                (C {(test)} {(-z)} 
                                                  {(DQ ($ VSub_DollarName '$convenience'))}
                                                )
                                                (C {(test)} {(-z)} 
                                                  {
                                                    (DQ 
                                                      ($ VSub_DollarName '$whole_archive_flag_spec')
                                                    )
                                                  }
                                                )
                                              ]
                                            )
                                          terminator: <Op_Semi ';'>
                                        )
                                      ]
                                      action: [
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:save_libobjs)
                                              op: Equal
                                              rhs: {($ VSub_DollarName '$libobjs')}
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                  ]
                                )
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:save_output)
                                      op: Equal
                                      rhs: {($ VSub_DollarName '$output')}
                                    )
                                  ]
                                )
                                (C {(func_basename)} {(DQ ($ VSub_DollarName '$output'))})
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:output_la)
                                      op: Equal
                                      rhs: {($ VSub_DollarName '$func_basename_result')}
                                    )
                                  ]
                                )
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:test_cmds)
                                      op: Equal
                                      rhs: (word.Empty)
                                    )
                                  ]
                                )
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:concat_cmds)
                                      op: Equal
                                      rhs: (word.Empty)
                                    )
                                  ]
                                )
                                (command.ShAssignment
                                  pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:objlist) op:Equal rhs:(word.Empty))]
                                )
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:last_robj)
                                      op: Equal
                                      rhs: (word.Empty)
                                    )
                                  ]
                                )
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:k)
                                      op: Equal
                                      rhs: {(1)}
                                    )
                                  ]
                                )
                                (command.If
                                  arms: [
                                    (if_arm
                                      cond: [
                                        (command.Sentence
                                          child: 
                                            (command.AndOr
                                              ops: [Op_DAmp Op_DAmp]
                                              children: [
                                                (C {(test)} {(-n)} 
                                                  {(DQ ($ VSub_DollarName '$save_libobjs'))}
                                                )
                                                (C {(test)} {(Lit_Other ':')} 
                                                  {(KW_Bang '!') (Lit_Equals '=')} {(DQ ($ VSub_DollarName '$skipped_export'))}
                                                )
                                                (C {(test)} {(yes)} {(Lit_Equals '=')} 
                                                  {(DQ ($ VSub_DollarName '$with_gnu_ld'))}
                                                )
                                              ]
                                            )
                                          terminator: <Op_Semi ';'>
                                        )
                                      ]
                                      action: [
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:output)
                                              op: Equal
                                              rhs: 
                                                {($ VSub_DollarName '$output_objdir') (/) 
                                                  ($ VSub_DollarName '$output_la') (.lnkscript)
                                                }
                                            )
                                          ]
                                        )
                                        (C {(func_verbose)} 
                                          {
                                            (DQ ('creating GNU ld script: ') 
                                              ($ VSub_DollarName '$output')
                                            )
                                          }
                                        )
                                        (command.Simple
                                          words: [{(echo)} {(SQ <'INPUT ('>)}]
                                          redirects: [
                                            (redir.Redir
                                              op: <Redir_Great '>'>
                                              fd: 16777215
                                              arg_word: {($ VSub_DollarName '$output')}
                                            )
                                          ]
                                        )
                                        (command.ForEach
                                          iter_name: obj
                                          iter_words: [{($ VSub_DollarName '$save_libobjs')}]
                                          do_arg_iter: F
                                          body: 
                                            (command.DoGroup
                                              children: [
                                                (C {(func_to_tool_file)} 
                                                  {(DQ ($ VSub_DollarName '$obj'))}
                                                )
                                                (command.Simple
                                                  words: [
                                                    {($ VSub_DollarName '$ECHO')}
                                                    {
                                                      (DQ 
                                                        ($ VSub_DollarName 
'$func_to_tool_file_result'
                                                        )
                                                      )
                                                    }
                                                  ]
                                                  redirects: [
                                                    (redir.Redir
                                                      op: <Redir_DGreat '>>'>
                                                      fd: 16777215
                                                      arg_word: {($ VSub_DollarName '$output')}
                                                    )
                                                  ]
                                                )
                                              ]
                                            )
                                        )
                                        (command.Simple
                                          words: [{(echo)} {(SQ <')'>)}]
                                          redirects: [
                                            (redir.Redir
                                              op: <Redir_DGreat '>>'>
                                              fd: 16777215
                                              arg_word: {($ VSub_DollarName '$output')}
                                            )
                                          ]
                                        )
                                        (C {(func_append)} {(delfiles)} 
                                          {(DQ (' ') ($ VSub_DollarName '$output'))}
                                        )
                                        (C {(func_to_tool_file)} {(DQ ($ VSub_DollarName '$output'))})
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:output)
                                              op: Equal
                                              rhs: {($ VSub_DollarName '$func_to_tool_file_result')}
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                    (if_arm
                                      cond: [
                                        (command.Sentence
                                          child: 
                                            (command.AndOr
                                              ops: [Op_DAmp Op_DAmp]
                                              children: [
                                                (C {(test)} {(-n)} 
                                                  {(DQ ($ VSub_DollarName '$save_libobjs'))}
                                                )
                                                (C {(test)} {(Lit_Other ':')} 
                                                  {(KW_Bang '!') (Lit_Equals '=')} {(DQ ($ VSub_DollarName '$skipped_export'))}
                                                )
                                                (C {(test)} {(-n)} 
                                                  {(DQ ($ VSub_DollarName '$file_list_spec'))}
                                                )
                                              ]
                                            )
                                          terminator: <Op_Semi ';'>
                                        )
                                      ]
                                      action: [
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:output)
                                              op: Equal
                                              rhs: 
                                                {($ VSub_DollarName '$output_objdir') (/) 
                                                  ($ VSub_DollarName '$output_la') (.lnk)
                                                }
                                            )
                                          ]
                                        )
                                        (C {(func_verbose)} 
                                          {
                                            (DQ ('creating linker input file list: ') 
                                              ($ VSub_DollarName '$output')
                                            )
                                          }
                                        )
                                        (command.Simple
                                          words: [{(Lit_Other ':')}]
                                          redirects: [
                                            (redir.Redir
                                              op: <Redir_Great '>'>
                                              fd: 16777215
                                              arg_word: {($ VSub_DollarName '$output')}
                                            )
                                          ]
                                        )
                                        (C {(KW_Set set)} {(x)} {($ VSub_DollarName '$save_libobjs')})
                                        (C {(shift)})
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:firstobj)
                                              op: Equal
                                              rhs: (word.Empty)
                                            )
                                          ]
                                        )
                                        (command.If
                                          arms: [
                                            (if_arm
                                              cond: [
                                                (command.Sentence
                                                  child: 
                                                    (C {(test)} {(yes)} {(Lit_Equals '=')} 
                                                      {
                                                        (DQ 
                                                          ($ VSub_DollarName '$compiler_needs_object')
                                                        )
                                                      }
                                                    )
                                                  terminator: <Op_Semi ';'>
                                                )
                                              ]
                                              action: [
                                                (command.ShAssignment
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (sh_lhs_expr.Name name:firstobj)
                                                      op: Equal
                                                      rhs: {(DQ ($ VSub_Number '$1') (' '))}
                                                    )
                                                  ]
                                                )
                                                (C {(shift)})
                                              ]
                                            )
                                          ]
                                        )
                                        (command.ForEach
                                          iter_name: obj
                                          do_arg_iter: T
                                          body: 
                                            (command.DoGroup
                                              children: [
                                                (C {(func_to_tool_file)} 
                                                  {(DQ ($ VSub_DollarName '$obj'))}
                                                )
                                                (command.Simple
                                                  words: [
                                                    {($ VSub_DollarName '$ECHO')}
                                                    {
                                                      (DQ 
                                                        ($ VSub_DollarName 
'$func_to_tool_file_result'
                                                        )
                                                      )
                                                    }
                                                  ]
                                                  redirects: [
                                                    (redir.Redir
                                                      op: <Redir_DGreat '>>'>
                                                      fd: 16777215
                                                      arg_word: {($ VSub_DollarName '$output')}
                                                    )
                                                  ]
                                                )
                                              ]
                                            )
                                        )
                                        (C {(func_append)} {(delfiles)} 
                                          {(DQ (' ') ($ VSub_DollarName '$output'))}
                                        )
                                        (C {(func_to_tool_file)} {(DQ ($ VSub_DollarName '$output'))})
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:output)
                                              op: Equal
                                              rhs: 
                                                {($ VSub_DollarName '$firstobj') 
                                                  (word_part.EscapedLiteral
                                                    token: <Lit_EscapedChar '\\"'>
                                                  ) ($ VSub_DollarName '$file_list_spec') ($ VSub_DollarName '$func_to_tool_file_result') 
                                                  (word_part.EscapedLiteral
                                                    token: <Lit_EscapedChar '\\"'>
                                                  )
                                                }
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                  ]
                                  else_action: [
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (command.Sentence
                                              child: 
                                                (C {(test)} {(-n)} 
                                                  {(DQ ($ VSub_DollarName '$save_libobjs'))}
                                                )
                                              terminator: <Op_Semi ';'>
                                            )
                                          ]
                                          action: [
                                            (C {(func_verbose)} 
                                              {(DQ ('creating reloadable object files...'))}
                                            )
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:output)
                                                  op: Equal
                                                  rhs: 
                                                    {($ VSub_DollarName '$output_objdir') (/) 
                                                      ($ VSub_DollarName '$output_la') (-) ($ VSub_DollarName '$k') (.) ($ VSub_DollarName '$objext')
                                                    }
                                                )
                                              ]
                                            )
                                            (C {(eval)} 
                                              {(Lit_VarLike 'test_cmds=') 
                                                (word_part.EscapedLiteral
                                                  token: <Lit_EscapedChar '\\"'>
                                                ) ($ VSub_DollarName '$reload_cmds') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>)
                                              }
                                            )
                                            (C {(func_len)} 
                                              {(DQ (' ') ($ VSub_DollarName '$test_cmds'))}
                                            )
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:len0)
                                                  op: Equal
                                                  rhs: {($ VSub_DollarName '$func_len_result')}
                                                )
                                              ]
                                            )
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:len)
                                                  op: Equal
                                                  rhs: {($ VSub_DollarName '$len0')}
                                                )
                                              ]
                                            )
                                            (command.ForEach
                                              iter_name: obj
                                              iter_words: [{($ VSub_DollarName '$save_libobjs')}]
                                              do_arg_iter: F
                                              body: 
                                                (command.DoGroup
                                                  children: [
                                                    (C {(func_len)} 
                                                      {(DQ (' ') ($ VSub_DollarName '$obj'))}
                                                    )
                                                    (C {(func_arith)} {($ VSub_DollarName '$len')} 
                                                      {(Lit_Other '+')} {($ VSub_DollarName '$func_len_result')}
                                                    )
                                                    (command.ShAssignment
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (sh_lhs_expr.Name name:len)
                                                          op: Equal
                                                          rhs: 
                                                            {
                                                              ($ VSub_DollarName '$func_arith_result')
                                                            }
                                                        )
                                                      ]
                                                    )
                                                    (command.If
                                                      arms: [
                                                        (if_arm
                                                          cond: [
                                                            (command.Sentence
                                                              child: 
                                                                (command.AndOr
                                                                  ops: [Op_DPipe]
                                                                  children: [
                                                                    (C {(test)} {(-z)} 
                                                                      {
                                                                        (DQ 
                                                                          ($ VSub_DollarName 
'$objlist'
                                                                          )
                                                                        )
                                                                      }
                                                                    )
                                                                    (C {(test)} 
                                                                      {
                                                                        (DQ 
                                                                          ($ VSub_DollarName '$len')
                                                                        )
                                                                      } {(-lt)} {(DQ ($ VSub_DollarName '$max_cmd_len'))}
                                                                    )
                                                                  ]
                                                                )
                                                              terminator: <Op_Semi ';'>
                                                            )
                                                          ]
                                                          action: [
                                                            (C {(func_append)} {(objlist)} 
                                                              {(DQ (' ') ($ VSub_DollarName '$obj'))}
                                                            )
                                                          ]
                                                        )
                                                      ]
                                                      else_action: [
                                                        (command.If
                                                          arms: [
                                                            (if_arm
                                                              cond: [
                                                                (command.Sentence
                                                                  child: 
                                                                    (C {(test)} {(1)} {(-eq)} 
                                                                      {(DQ ($ VSub_DollarName '$k'))}
                                                                    )
                                                                  terminator: <Op_Semi ';'>
                                                                )
                                                              ]
                                                              action: [
                                                                (command.ShAssignment
                                                                  pairs: [
                                                                    (assign_pair
                                                                      lhs: 
                                                                        (sh_lhs_expr.Name
                                                                          name: reload_objs
                                                                        )
                                                                      op: Equal
                                                                      rhs: 
                                                                        {
                                                                          ($ VSub_DollarName 
'$objlist'
                                                                          )
                                                                        }
                                                                    )
                                                                  ]
                                                                )
                                                                (C {(eval)} 
                                                                  {(Lit_VarLike 'concat_cmds=') 
                                                                    (word_part.EscapedLiteral
                                                                      token: <Lit_EscapedChar '\\"'>
                                                                    ) ($ VSub_DollarName '$reload_cmds') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>)
                                                                  }
                                                                )
                                                              ]
                                                            )
                                                          ]
                                                          else_action: [
                                                            (command.ShAssignment
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: 
                                                                    (sh_lhs_expr.Name
                                                                      name: reload_objs
                                                                    )
                                                                  op: Equal
                                                                  rhs: 
                                                                    {
                                                                      (DQ 
                                                                        ($ VSub_DollarName '$objlist') (' ') ($ VSub_DollarName '$last_robj')
                                                                      )
                                                                    }
                                                                )
                                                              ]
                                                            )
                                                            (C {(eval)} 
                                                              {(Lit_VarLike 'concat_cmds=') 
                                                                (word_part.EscapedLiteral
                                                                  token: <Lit_EscapedChar '\\"'>
                                                                ) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) (concat_cmds) (Lit_TildeLike '~') 
                                                                ($ VSub_DollarName '$reload_cmds') (Lit_TildeLike '~') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) (RM)
                                                              } {($ VSub_DollarName '$last_robj') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>)}
                                                            )
                                                          ]
                                                        )
                                                        (command.ShAssignment
                                                          pairs: [
                                                            (assign_pair
                                                              lhs: (sh_lhs_expr.Name name:last_robj)
                                                              op: Equal
                                                              rhs: 
                                                                {
                                                                  ($ VSub_DollarName '$output_objdir') (/) ($ VSub_DollarName '$output_la') (-) ($ VSub_DollarName '$k') (.) ($ VSub_DollarName '$objext')
                                                                }
                                                            )
                                                          ]
                                                        )
                                                        (C {(func_arith)} {($ VSub_DollarName '$k')} 
                                                          {(Lit_Other '+')} {(1)}
                                                        )
                                                        (command.ShAssignment
                                                          pairs: [
                                                            (assign_pair
                                                              lhs: (sh_lhs_expr.Name name:k)
                                                              op: Equal
                                                              rhs: 
                                                                {
                                                                  ($ VSub_DollarName 
'$func_arith_result'
                                                                  )
                                                                }
                                                            )
                                                          ]
                                                        )
                                                        (command.ShAssignment
                                                          pairs: [
                                                            (assign_pair
                                                              lhs: (sh_lhs_expr.Name name:output)
                                                              op: Equal
                                                              rhs: 
                                                                {
                                                                  ($ VSub_DollarName '$output_objdir') (/) ($ VSub_DollarName '$output_la') (-) ($ VSub_DollarName '$k') (.) ($ VSub_DollarName '$objext')
                                                                }
                                                            )
                                                          ]
                                                        )
                                                        (command.ShAssignment
                                                          pairs: [
                                                            (assign_pair
                                                              lhs: (sh_lhs_expr.Name name:objlist)
                                                              op: Equal
                                                              rhs: 
                                                                {
                                                                  (DQ (' ') ($ VSub_DollarName '$obj'))
                                                                }
                                                            )
                                                          ]
                                                        )
                                                        (C {(func_len)} 
                                                          {
                                                            (DQ (' ') ($ VSub_DollarName '$last_robj'))
                                                          }
                                                        )
                                                        (C {(func_arith)} {($ VSub_DollarName '$len0')} 
                                                          {(Lit_Other '+')} {($ VSub_DollarName '$func_len_result')}
                                                        )
                                                        (command.ShAssignment
                                                          pairs: [
                                                            (assign_pair
                                                              lhs: (sh_lhs_expr.Name name:len)
                                                              op: Equal
                                                              rhs: 
                                                                {
                                                                  ($ VSub_DollarName 
'$func_arith_result'
                                                                  )
                                                                }
                                                            )
                                                          ]
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                )
                                            )
                                            (command.AndOr
                                              ops: [Op_DPipe]
                                              children: [
                                                (C {(test)} {(-z)} 
                                                  {(DQ ($ VSub_DollarName '$concat_cmds'))}
                                                )
                                                (command.ShAssignment
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (sh_lhs_expr.Name name:concat_cmds)
                                                      op: Equal
                                                      rhs: 
                                                        {($ VSub_DollarName '$concat_cmds') 
                                                          (Lit_TildeLike '~')
                                                        }
                                                    )
                                                  ]
                                                )
                                              ]
                                            )
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:reload_objs)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ ($ VSub_DollarName '$objlist') (' ') 
                                                        ($ VSub_DollarName '$last_robj')
                                                      )
                                                    }
                                                )
                                              ]
                                            )
                                            (C {(eval)} 
                                              {(Lit_VarLike 'concat_cmds=') 
                                                (word_part.EscapedLiteral
                                                  token: <Lit_EscapedChar '\\"'>
                                                ) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) (concat_cmds) 
                                                ($ VSub_DollarName '$reload_cmds') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>)
                                              }
                                            )
                                            (command.If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (command.Sentence
                                                      child: 
                                                        (C {(test)} {(-n)} 
                                                          {(DQ ($ VSub_DollarName '$last_robj'))}
                                                        )
                                                      terminator: <Op_Semi ';'>
                                                    )
                                                  ]
                                                  action: [
                                                    (C {(eval)} 
                                                      {(Lit_VarLike 'concat_cmds=') 
                                                        (word_part.EscapedLiteral
                                                          token: <Lit_EscapedChar '\\"'>
                                                        ) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) (concat_cmds) (Lit_TildeLike '~') 
                                                        (word_part.EscapedLiteral
                                                          token: <Lit_EscapedChar '\\$'>
                                                        ) (RM)
                                                      } {($ VSub_DollarName '$last_robj') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>)}
                                                    )
                                                  ]
                                                )
                                              ]
                                            )
                                            (C {(func_append)} {(delfiles)} 
                                              {(DQ (' ') ($ VSub_DollarName '$output'))}
                                            )
                                          ]
                                        )
                                      ]
                                      else_action: [
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:output)
                                              op: Equal
                                              rhs: (word.Empty)
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                    (command.AndOr
                                      ops: [Op_DAmp]
                                      children: [
                                        (C 
                                          {
                                            (braced_var_sub
                                              token: <VSub_Name skipped_export>
                                              suffix_op: 
                                                (suffix_op.Unary
                                                  op_id: VTest_Hyphen
                                                  arg_word: {(false)}
                                                )
                                            )
                                          }
                                        )
                                        (command.BraceGroup
                                          children: [
                                            (C {(func_verbose)} 
                                              {
                                                (DQ ("generating symbol list for '") 
                                                  ($ VSub_DollarName '$libname') (".la'")
                                                )
                                              }
                                            )
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:export_symbols)
                                                  op: Equal
                                                  rhs: 
                                                    {($ VSub_DollarName '$output_objdir') (/) 
                                                      ($ VSub_DollarName '$libname') (.exp)
                                                    }
                                                )
                                              ]
                                            )
                                            (command.AndOr
                                              ops: [Op_DPipe]
                                              children: [
                                                (C {($ VSub_DollarName '$opt_dry_run')})
                                                (C {($ VSub_DollarName '$RM')} 
                                                  {($ VSub_DollarName '$export_symbols')}
                                                )
                                              ]
                                            )
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:libobjs)
                                                  op: Equal
                                                  rhs: {($ VSub_DollarName '$output')}
                                                )
                                              ]
                                            )
                                            (command.AndOr
                                              ops: [Op_DPipe]
                                              children: [
                                                (C {(test)} {(-z)} 
                                                  {(DQ ($ VSub_DollarName '$concat_cmds'))}
                                                )
                                                (command.ShAssignment
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (sh_lhs_expr.Name name:concat_cmds)
                                                      op: Equal
                                                      rhs: 
                                                        {($ VSub_DollarName '$concat_cmds') 
                                                          (Lit_TildeLike '~')
                                                        }
                                                    )
                                                  ]
                                                )
                                              ]
                                            )
                                            (C {(eval)} 
                                              {(Lit_VarLike 'concat_cmds=') 
                                                (word_part.EscapedLiteral
                                                  token: <Lit_EscapedChar '\\"'>
                                                ) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) (concat_cmds) 
                                                ($ VSub_DollarName '$export_symbols_cmds') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>)
                                              }
                                            )
                                            (command.If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (command.Sentence
                                                      child: 
                                                        (C {(test)} {(-n)} 
                                                          {(DQ ($ VSub_DollarName '$last_robj'))}
                                                        )
                                                      terminator: <Op_Semi ';'>
                                                    )
                                                  ]
                                                  action: [
                                                    (C {(eval)} 
                                                      {(Lit_VarLike 'concat_cmds=') 
                                                        (word_part.EscapedLiteral
                                                          token: <Lit_EscapedChar '\\"'>
                                                        ) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) (concat_cmds) (Lit_TildeLike '~') 
                                                        (word_part.EscapedLiteral
                                                          token: <Lit_EscapedChar '\\$'>
                                                        ) (RM)
                                                      } {($ VSub_DollarName '$last_robj') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>)}
                                                    )
                                                  ]
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                    (command.AndOr
                                      ops: [Op_DAmp]
                                      children: [
                                        (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$save_libobjs'))})
                                        (C {(func_verbose)} 
                                          {
                                            (DQ ('creating a temporary reloadable object file: ') 
                                              ($ VSub_DollarName '$output')
                                            )
                                          }
                                        )
                                      ]
                                    )
                                    (command.Sentence
                                      child: 
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:save_ifs)
                                              op: Equal
                                              rhs: {($ VSub_DollarName '$IFS')}
                                            )
                                          ]
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:IFS)
                                          op: Equal
                                          rhs: {(SQ <'~'>)}
                                        )
                                      ]
                                    )
                                    (command.ForEach
                                      iter_name: cmd
                                      iter_words: [{($ VSub_DollarName '$concat_cmds')}]
                                      do_arg_iter: F
                                      body: 
                                        (command.DoGroup
                                          children: [
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:IFS)
                                                  op: Equal
                                                  rhs: {($ VSub_DollarName '$save_ifs')}
                                                )
                                              ]
                                            )
                                            (command.AndOr
                                              ops: [Op_DPipe]
                                              children: [
                                                (C {($ VSub_DollarName '$opt_quiet')})
                                                (command.BraceGroup
                                                  children: [
                                                    (C {(func_quote_for_expand)} 
                                                      {(DQ ($ VSub_DollarName '$cmd'))}
                                                    )
                                                    (C {(eval)} 
                                                      {
                                                        (DQ ('func_echo ') 
                                                          ($ VSub_DollarName 
'$func_quote_for_expand_result'
                                                          )
                                                        )
                                                      }
                                                    )
                                                  ]
                                                )
                                              ]
                                            )
                                            (command.AndOr
                                              ops: [Op_DPipe Op_DPipe]
                                              children: [
                                                (C {($ VSub_DollarName '$opt_dry_run')})
                                                (C {(eval)} {(DQ ($ VSub_DollarName '$cmd'))})
                                                (command.BraceGroup
                                                  children: [
                                                    (command.ShAssignment
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (sh_lhs_expr.Name name:lt_exit)
                                                          op: Equal
                                                          rhs: {($ VSub_QMark '$?')}
                                                        )
                                                      ]
                                                    )
                                                    (command.If
                                                      arms: [
                                                        (if_arm
                                                          cond: [
                                                            (command.Sentence
                                                              child: 
                                                                (C {(test)} {(relink)} 
                                                                  {(Lit_Equals '=')} {(DQ ($ VSub_DollarName '$opt_mode'))}
                                                                )
                                                              terminator: <Op_Semi ';'>
                                                            )
                                                          ]
                                                          action: [
                                                            (command.Subshell
                                                              command_list: 
                                                                (command.CommandList
                                                                  children: [
                                                                    (command.AndOr
                                                                      ops: [Op_DAmp Op_DAmp]
                                                                      children: [
                                                                        (C {(cd)} 
                                                                          {
                                                                            (DQ 
                                                                              ($ VSub_DollarName 
'$output_objdir'
                                                                              )
                                                                            )
                                                                          }
                                                                        )
                                                                        (C {($ VSub_DollarName '$RM')} 
                                                                          {
                                                                            (DQ 
                                                                              (${ VSub_Name realname) (T)
                                                                            )
                                                                          }
                                                                        )
                                                                        (C {($ VSub_DollarName '$MV')} 
                                                                          {
                                                                            (DQ 
                                                                              (${ VSub_Name realname) (U)
                                                                            )
                                                                          } {(DQ ($ VSub_DollarName '$realname'))}
                                                                        )
                                                                      ]
                                                                    )
                                                                  ]
                                                                )
                                                            )
                                                          ]
                                                        )
                                                      ]
                                                    )
                                                    (command.ControlFlow
                                                      token: <ControlFlow_Exit exit>
                                                      arg_word: {($ VSub_DollarName '$lt_exit')}
                                                    )
                                                  ]
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:IFS)
                                          op: Equal
                                          rhs: {($ VSub_DollarName '$save_ifs')}
                                        )
                                      ]
                                    )
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (command.Sentence
                                              child: 
                                                (command.AndOr
                                                  ops: [Op_DAmp]
                                                  children: [
                                                    (C {(test)} {(-n)} 
                                                      {
                                                        (DQ 
                                                          ($ VSub_DollarName '$export_symbols_regex')
                                                        )
                                                      }
                                                    )
                                                    (C 
                                                      {
                                                        (braced_var_sub
                                                          token: <VSub_Name skipped_export>
                                                          suffix_op: 
                                                            (suffix_op.Unary
                                                              op_id: VTest_Hyphen
                                                              arg_word: {(false)}
                                                            )
                                                        )
                                                      }
                                                    )
                                                  ]
                                                )
                                              terminator: <Op_Semi ';'>
                                            )
                                          ]
                                          action: [
                                            (C {(func_show_eval)} 
                                              {
                                                (SQ 
                                                  <
'$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
                                                  >
                                                )
                                              }
                                            )
                                            (C {(func_show_eval)} 
                                              {(SQ <'$MV "${export_symbols}T" "$export_symbols"'>)}
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                  ]
                                )
                                (command.AndOr
                                  ops: [Op_DAmp]
                                  children: [
                                    (C 
                                      {
                                        (braced_var_sub
                                          token: <VSub_Name skipped_export>
                                          suffix_op: 
                                            (suffix_op.Unary
                                              op_id: VTest_Hyphen
                                              arg_word: {(false)}
                                            )
                                        )
                                      }
                                    )
                                    (command.BraceGroup
                                      children: [
                                        (command.If
                                          arms: [
                                            (if_arm
                                              cond: [
                                                (command.Sentence
                                                  child: 
                                                    (command.AndOr
                                                      ops: [Op_DAmp]
                                                      children: [
                                                        (C {(test)} {(-n)} 
                                                          {(DQ ($ VSub_DollarName '$export_symbols'))}
                                                        )
                                                        (C {(test)} {(-n)} 
                                                          {
                                                            (DQ 
                                                              ($ VSub_DollarName '$include_expsyms')
                                                            )
                                                          }
                                                        )
                                                      ]
                                                    )
                                                  terminator: <Op_Semi ';'>
                                                )
                                              ]
                                              action: [
                                                (command.ShAssignment
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (sh_lhs_expr.Name name:tmp_export_symbols)
                                                      op: Equal
                                                      rhs: {($ VSub_DollarName '$export_symbols')}
                                                    )
                                                  ]
                                                )
                                                (command.AndOr
                                                  ops: [Op_DAmp]
                                                  children: [
                                                    (C {(test)} {(-n)} 
                                                      {
                                                        (DQ 
                                                          ($ VSub_DollarName '$orig_export_symbols')
                                                        )
                                                      }
                                                    )
                                                    (command.ShAssignment
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: 
                                                            (sh_lhs_expr.Name
                                                              name: tmp_export_symbols
                                                            )
                                                          op: Equal
                                                          rhs: 
                                                            {
                                                              ($ VSub_DollarName 
'$orig_export_symbols'
                                                              )
                                                            }
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                )
                                                (command.AndOr
                                                  ops: [Op_DPipe]
                                                  children: [
                                                    (C {($ VSub_DollarName '$opt_dry_run')})
                                                    (C {(eval)} 
                                                      {
                                                        (SQ 
                                                          <
'$ECHO "$include_expsyms" | $SP2NL >> "$tmp_export_symbols"'
                                                          >
                                                        )
                                                      }
                                                    )
                                                  ]
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                        (command.If
                                          arms: [
                                            (if_arm
                                              cond: [
                                                (command.Sentence
                                                  child: 
                                                    (C {(test)} {(-n)} 
                                                      {
                                                        (DQ 
                                                          ($ VSub_DollarName '$orig_export_symbols')
                                                        )
                                                      }
                                                    )
                                                  terminator: <Op_Semi ';'>
                                                )
                                              ]
                                              action: [
                                                (C {(func_verbose)} 
                                                  {
                                                    (DQ ("filter symbol list for '") 
                                                      ($ VSub_DollarName '$libname') (".la' to tag DATA exports")
                                                    )
                                                  }
                                                )
                                                (command.AndOr
                                                  ops: [Op_DPipe]
                                                  children: [
                                                    (C {($ VSub_DollarName '$opt_dry_run')})
                                                    (command.Simple
                                                      words: [
                                                        {($ VSub_DollarName '$SED')}
                                                        {(-e)}
                                                        {
                                                          (SQ 
                                                            <
'/[ ,]DATA/!d;s,\\(.*\\)\\([ \\,].*\\),s|^\\1$|\\1\\2|,'
                                                            >
                                                          )
                                                        }
                                                      ]
                                                      redirects: [
                                                        (redir.Redir
                                                          op: <Redir_Less '<'>
                                                          fd: 16777215
                                                          arg_word: 
                                                            {($ VSub_DollarName '$export_symbols')}
                                                        )
                                                        (redir.Redir
                                                          op: <Redir_Great '>'>
                                                          fd: 16777215
                                                          arg_word: 
                                                            {($ VSub_DollarName '$output_objdir') (/) 
                                                              ($ VSub_DollarName '$libname') (.filter)
                                                            }
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                )
                                                (C {(func_append)} {(delfiles)} 
                                                  {
                                                    (DQ (' ') ($ VSub_DollarName '$export_symbols') 
                                                      (' ') ($ VSub_DollarName '$output_objdir') (/) ($ VSub_DollarName '$libname') (.filter)
                                                    )
                                                  }
                                                )
                                                (command.ShAssignment
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (sh_lhs_expr.Name name:export_symbols)
                                                      op: Equal
                                                      rhs: 
                                                        {($ VSub_DollarName '$output_objdir') (/) 
                                                          ($ VSub_DollarName '$libname') (.def)
                                                        }
                                                    )
                                                  ]
                                                )
                                                (command.AndOr
                                                  ops: [Op_DPipe]
                                                  children: [
                                                    (C {($ VSub_DollarName '$opt_dry_run')})
                                                    (command.Simple
                                                      words: [
                                                        {($ VSub_DollarName '$SED')}
                                                        {(-f)}
                                                        {($ VSub_DollarName '$output_objdir') (/) 
                                                          ($ VSub_DollarName '$libname') (.filter)
                                                        }
                                                      ]
                                                      redirects: [
                                                        (redir.Redir
                                                          op: <Redir_Less '<'>
                                                          fd: 16777215
                                                          arg_word: 
                                                            {
                                                              ($ VSub_DollarName 
'$orig_export_symbols'
                                                              )
                                                            }
                                                        )
                                                        (redir.Redir
                                                          op: <Redir_Great '>'>
                                                          fd: 16777215
                                                          arg_word: 
                                                            {($ VSub_DollarName '$export_symbols')}
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                  ]
                                )
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:libobjs)
                                      op: Equal
                                      rhs: {($ VSub_DollarName '$output')}
                                    )
                                  ]
                                )
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:output)
                                      op: Equal
                                      rhs: {($ VSub_DollarName '$save_output')}
                                    )
                                  ]
                                )
                                (command.If
                                  arms: [
                                    (if_arm
                                      cond: [
                                        (command.Sentence
                                          child: 
                                            (command.AndOr
                                              ops: [Op_DAmp]
                                              children: [
                                                (C {(test)} {(-n)} 
                                                  {(DQ ($ VSub_DollarName '$convenience'))}
                                                )
                                                (C {(test)} {(-n)} 
                                                  {
                                                    (DQ 
                                                      ($ VSub_DollarName '$whole_archive_flag_spec')
                                                    )
                                                  }
                                                )
                                              ]
                                            )
                                          terminator: <Op_Semi ';'>
                                        )
                                      ]
                                      action: [
                                        (C {(eval)} 
                                          {(Lit_VarLike 'libobjs=') 
                                            (word_part.EscapedLiteral
                                              token: <Lit_EscapedChar '\\"'>
                                            ) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) (libobjs)
                                          } 
                                          {($ VSub_DollarName '$whole_archive_flag_spec') 
                                            (word_part.EscapedLiteral
                                              token: <Lit_EscapedChar '\\"'>
                                            )
                                          }
                                        )
                                        (command.AndOr
                                          ops: [Op_DAmp]
                                          children: [
                                            (C {(test)} {(DQ (X) ($ VSub_DollarName '$libobjs'))} 
                                              {(Lit_Equals '=')} {(DQ ('X '))}
                                            )
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:libobjs)
                                                  op: Equal
                                                  rhs: (word.Empty)
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                  ]
                                )
                                (command.If
                                  arms: [
                                    (if_arm
                                      cond: [
                                        (command.Sentence
                                          child: 
                                            (command.AndOr
                                              ops: [Op_DAmp]
                                              children: [
                                                (C {(test)} {(yes)} {(Lit_Equals '=')} 
                                                  {(DQ ($ VSub_DollarName '$module'))}
                                                )
                                                (C {(test)} {(-n)} 
                                                  {(DQ ($ VSub_DollarName '$module_cmds'))}
                                                )
                                              ]
                                            )
                                          terminator: <Op_Semi ';'>
                                        )
                                      ]
                                      action: [
                                        (command.If
                                          arms: [
                                            (if_arm
                                              cond: [
                                                (command.Sentence
                                                  child: 
                                                    (command.AndOr
                                                      ops: [Op_DAmp]
                                                      children: [
                                                        (C {(test)} {(-n)} 
                                                          {(DQ ($ VSub_DollarName '$export_symbols'))}
                                                        )
                                                        (C {(test)} {(-n)} 
                                                          {
                                                            (DQ 
                                                              ($ VSub_DollarName 
'$module_expsym_cmds'
                                                              )
                                                            )
                                                          }
                                                        )
                                                      ]
                                                    )
                                                  terminator: <Op_Semi ';'>
                                                )
                                              ]
                                              action: [
                                                (command.ShAssignment
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (sh_lhs_expr.Name name:cmds)
                                                      op: Equal
                                                      rhs: {($ VSub_DollarName '$module_expsym_cmds')}
                                                    )
                                                  ]
                                                )
                                              ]
                                            )
                                          ]
                                          else_action: [
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:cmds)
                                                  op: Equal
                                                  rhs: {($ VSub_DollarName '$module_cmds')}
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                  ]
                                  else_action: [
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (command.Sentence
                                              child: 
                                                (command.AndOr
                                                  ops: [Op_DAmp]
                                                  children: [
                                                    (C {(test)} {(-n)} 
                                                      {(DQ ($ VSub_DollarName '$export_symbols'))}
                                                    )
                                                    (C {(test)} {(-n)} 
                                                      {
                                                        (DQ 
                                                          ($ VSub_DollarName '$archive_expsym_cmds')
                                                        )
                                                      }
                                                    )
                                                  ]
                                                )
                                              terminator: <Op_Semi ';'>
                                            )
                                          ]
                                          action: [
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:cmds)
                                                  op: Equal
                                                  rhs: {($ VSub_DollarName '$archive_expsym_cmds')}
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                      ]
                                      else_action: [
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:cmds)
                                              op: Equal
                                              rhs: {($ VSub_DollarName '$archive_cmds')}
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$delfiles'))})
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (C {(eval)} 
                                      {(Lit_VarLike 'cmds=') 
                                        (word_part.EscapedLiteral
                                          token: <Lit_EscapedChar '\\"'>
                                        ) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) (cmds) (Lit_TildeLike '~') 
                                        (word_part.EscapedLiteral
                                          token: <Lit_EscapedChar '\\$'>
                                        ) (RM)
                                      } {($ VSub_DollarName '$delfiles') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>)}
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$dlprefiles'))})
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:gentop)
                                          op: Equal
                                          rhs: 
                                            {($ VSub_DollarName '$output_objdir') (/) 
                                              (${ VSub_Name outputname) (x)
                                            }
                                        )
                                      ]
                                    )
                                    (C {(func_append)} {(generated)} 
                                      {(DQ (' ') ($ VSub_DollarName '$gentop'))}
                                    )
                                    (C {(func_extract_archives)} {($ VSub_DollarName '$gentop')} 
                                      {($ VSub_DollarName '$dlprefiles')}
                                    )
                                    (C {(func_append)} {(libobjs)} 
                                      {(DQ (' ') ($ VSub_DollarName '$func_extract_archives_result'))}
                                    )
                                    (command.AndOr
                                      ops: [Op_DAmp]
                                      children: [
                                        (C {(test)} {(DQ (X) ($ VSub_DollarName '$libobjs'))} 
                                          {(Lit_Equals '=')} {(DQ ('X '))}
                                        )
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:libobjs)
                                              op: Equal
                                              rhs: (word.Empty)
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.Sentence
                              child: 
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:save_ifs)
                                      op: Equal
                                      rhs: {($ VSub_DollarName '$IFS')}
                                    )
                                  ]
                                )
                              terminator: <Op_Semi ';'>
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:IFS)
                                  op: Equal
                                  rhs: {(SQ <'~'>)}
                                )
                              ]
                            )
                            (command.ForEach
                              iter_name: cmd
                              iter_words: [{($ VSub_DollarName '$cmds')}]
                              do_arg_iter: F
                              body: 
                                (command.DoGroup
                                  children: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:IFS)
                                          op: Equal
                                          rhs: {($ VSub_DollarName '$sp') ($ VSub_DollarName '$nl')}
                                        )
                                      ]
                                    )
                                    (C {(eval)} 
                                      {(Lit_VarLike 'cmd=') 
                                        (word_part.EscapedLiteral
                                          token: <Lit_EscapedChar '\\"'>
                                        ) ($ VSub_DollarName '$cmd') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>)
                                      }
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:IFS)
                                          op: Equal
                                          rhs: {($ VSub_DollarName '$save_ifs')}
                                        )
                                      ]
                                    )
                                    (command.AndOr
                                      ops: [Op_DPipe]
                                      children: [
                                        (C {($ VSub_DollarName '$opt_quiet')})
                                        (command.BraceGroup
                                          children: [
                                            (C {(func_quote_for_expand)} 
                                              {(DQ ($ VSub_DollarName '$cmd'))}
                                            )
                                            (C {(eval)} 
                                              {
                                                (DQ ('func_echo ') 
                                                  ($ VSub_DollarName '$func_quote_for_expand_result')
                                                )
                                              }
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                    (command.AndOr
                                      ops: [Op_DPipe Op_DPipe]
                                      children: [
                                        (C {($ VSub_DollarName '$opt_dry_run')})
                                        (C {(eval)} {(DQ ($ VSub_DollarName '$cmd'))})
                                        (command.BraceGroup
                                          children: [
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:lt_exit)
                                                  op: Equal
                                                  rhs: {($ VSub_QMark '$?')}
                                                )
                                              ]
                                            )
                                            (command.If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (command.Sentence
                                                      child: 
                                                        (C {(test)} {(relink)} {(Lit_Equals '=')} 
                                                          {(DQ ($ VSub_DollarName '$opt_mode'))}
                                                        )
                                                      terminator: <Op_Semi ';'>
                                                    )
                                                  ]
                                                  action: [
                                                    (command.Subshell
                                                      command_list: 
                                                        (command.CommandList
                                                          children: [
                                                            (command.AndOr
                                                              ops: [Op_DAmp Op_DAmp]
                                                              children: [
                                                                (C {(cd)} 
                                                                  {
                                                                    (DQ 
                                                                      ($ VSub_DollarName 
'$output_objdir'
                                                                      )
                                                                    )
                                                                  }
                                                                )
                                                                (C {($ VSub_DollarName '$RM')} 
                                                                  {(DQ (${ VSub_Name realname) (T))}
                                                                )
                                                                (C {($ VSub_DollarName '$MV')} 
                                                                  {(DQ (${ VSub_Name realname) (U))} {(DQ ($ VSub_DollarName '$realname'))}
                                                                )
                                                              ]
                                                            )
                                                          ]
                                                        )
                                                    )
                                                  ]
                                                )
                                              ]
                                            )
                                            (command.ControlFlow
                                              token: <ControlFlow_Exit exit>
                                              arg_word: {($ VSub_DollarName '$lt_exit')}
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                  ]
                                )
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:IFS)
                                  op: Equal
                                  rhs: {($ VSub_DollarName '$save_ifs')}
                                )
                              ]
                            )
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (C {(test)} {(relink)} {(Lit_Equals '=')} 
                                          {(DQ ($ VSub_DollarName '$opt_mode'))}
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (command.AndOr
                                      ops: [Op_DPipe Op_DPipe]
                                      children: [
                                        (C {($ VSub_DollarName '$opt_dry_run')})
                                        (C {(eval)} 
                                          {
                                            (SQ 
                                              <
'(cd $output_objdir && $RM ${realname}T && $MV $realname ${realname}T && $MV ${realname}U $realname)'
                                              >
                                            )
                                          }
                                        )
                                        (command.ControlFlow
                                          token: <ControlFlow_Exit exit>
                                          arg_word: {($ VSub_QMark '$?')}
                                        )
                                      ]
                                    )
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (command.Sentence
                                              child: 
                                                (C {(test)} {(-n)} 
                                                  {(DQ ($ VSub_DollarName '$convenience'))}
                                                )
                                              terminator: <Op_Semi ';'>
                                            )
                                          ]
                                          action: [
                                            (command.If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (command.Sentence
                                                      child: 
                                                        (C {(test)} {(-z)} 
                                                          {
                                                            (DQ 
                                                              ($ VSub_DollarName 
'$whole_archive_flag_spec'
                                                              )
                                                            )
                                                          }
                                                        )
                                                      terminator: <Op_Semi ';'>
                                                    )
                                                  ]
                                                  action: [
                                                    (C {(func_show_eval)} {(SQ <'${RM}r "$gentop"'>)})
                                                  ]
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                    (command.ControlFlow
                                      token: <ControlFlow_Exit exit>
                                      arg_word: {($ VSub_DollarName '$EXIT_SUCCESS')}
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.ForEach
                              iter_name: linkname
                              iter_words: [{($ VSub_DollarName '$linknames')}]
                              do_arg_iter: F
                              body: 
                                (command.DoGroup
                                  children: [
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (command.Sentence
                                              child: 
                                                (C {(test)} {(DQ ($ VSub_DollarName '$realname'))} 
                                                  {(KW_Bang '!') (Lit_Equals '=')} {(DQ ($ VSub_DollarName '$linkname'))}
                                                )
                                              terminator: <Op_Semi ';'>
                                            )
                                          ]
                                          action: [
                                            (C {(func_show_eval)} 
                                              {
                                                (SQ 
                                                  <
'(cd "$output_objdir" && $RM "$linkname" && $LN_S "$realname" "$linkname")'
                                                  >
                                                )
                                              } {(SQ <'exit $?'>)}
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                  ]
                                )
                            )
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (command.AndOr
                                          ops: [Op_DPipe]
                                          children: [
                                            (C {(test)} {(yes)} {(Lit_Equals '=')} 
                                              {(DQ ($ VSub_DollarName '$module'))}
                                            )
                                            (C {(test)} {(yes)} {(Lit_Equals '=')} 
                                              {(DQ ($ VSub_DollarName '$export_dynamic'))}
                                            )
                                          ]
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:dlname)
                                          op: Equal
                                          rhs: {($ VSub_DollarName '$soname')}
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                            )
                          ]
                        )
                      ]
                    )
                  ]
                )
                (case_arm
                  pat_list: [{(obj)}]
                  action: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: 
                                (command.AndOr
                                  ops: [Op_DPipe]
                                  children: [
                                    (C {(test)} {(-n)} 
                                      {
                                        (DQ ($ VSub_DollarName '$dlfiles') 
                                          ($ VSub_DollarName '$dlprefiles')
                                        )
                                      }
                                    )
                                    (C {(test)} {(no)} {(KW_Bang '!') (Lit_Equals '=')} 
                                      {(DQ ($ VSub_DollarName '$dlself'))}
                                    )
                                  ]
                                )
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [(C {(func_warning)} {(DQ ("'-dlopen' is ignored for objects"))})]
                        )
                      ]
                    )
                    (command.Case
                      to_match: {(DQ (' ') ($ VSub_DollarName '$deplibs'))}
                      arms: [
                        (case_arm
                          pat_list: [
                            {(Lit_Star '*') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\ '>) 
                              (-l) (Lit_Star '*')
                            }
                            {(Lit_Star '*') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\ '>) 
                              (-L) (Lit_Star '*')
                            }
                          ]
                          action: [(C {(func_warning)} {(DQ ("'-l' and '-L' are ignored for objects"))})]
                        )
                      ]
                    )
                    (command.AndOr
                      ops: [Op_DAmp]
                      children: [
                        (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$rpath'))})
                        (C {(func_warning)} {(DQ ("'-rpath' is ignored for objects"))})
                      ]
                    )
                    (command.AndOr
                      ops: [Op_DAmp]
                      children: [
                        (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$xrpath'))})
                        (C {(func_warning)} {(DQ ("'-R' is ignored for objects"))})
                      ]
                    )
                    (command.AndOr
                      ops: [Op_DAmp]
                      children: [
                        (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$vinfo'))})
                        (C {(func_warning)} {(DQ ("'-version-info' is ignored for objects"))})
                      ]
                    )
                    (command.AndOr
                      ops: [Op_DAmp]
                      children: [
                        (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$release'))})
                        (C {(func_warning)} {(DQ ("'-release' is ignored for objects"))})
                      ]
                    )
                    (command.Case
                      to_match: {($ VSub_DollarName '$output')}
                      arms: [
                        (case_arm
                          pat_list: [{(Lit_Star '*') (.lo)}]
                          action: [
                            (command.AndOr
                              ops: [Op_DAmp]
                              children: [
                                (C {(test)} {(-n)} 
                                  {
                                    (DQ ($ VSub_DollarName '$objs') ($ VSub_DollarName '$old_deplibs'))
                                  }
                                )
                                (C {(func_fatal_error)} 
                                  {
                                    (DQ ("cannot build library object '") 
                                      ($ VSub_DollarName '$output') ("' from non-libtool objects")
                                    )
                                  }
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:libobj)
                                  op: Equal
                                  rhs: {($ VSub_DollarName '$output')}
                                )
                              ]
                            )
                            (C {(func_lo2o)} {(DQ ($ VSub_DollarName '$libobj'))})
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:obj)
                                  op: Equal
                                  rhs: {($ VSub_DollarName '$func_lo2o_result')}
                                )
                              ]
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(Lit_Star '*')}]
                          action: [
                            (command.ShAssignment
                              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:libobj) op:Equal rhs:(word.Empty))]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:obj)
                                  op: Equal
                                  rhs: {($ VSub_DollarName '$output')}
                                )
                              ]
                            )
                          ]
                        )
                      ]
                    )
                    (command.AndOr
                      ops: [Op_DPipe]
                      children: [
                        (C {($ VSub_DollarName '$opt_dry_run')})
                        (C {($ VSub_DollarName '$RM')} {($ VSub_DollarName '$obj')} 
                          {($ VSub_DollarName '$libobj')}
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:reload_conv_objs) op:Equal rhs:(word.Empty))]
                    )
                    (command.ShAssignment
                      pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:gentop) op:Equal rhs:(word.Empty))]
                    )
                    (command.Case
                      to_match: {($ VSub_DollarName '$reload_cmds')}
                      arms: [
                        (case_arm
                          pat_list: [
                            {(Lit_Star '*') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) 
                              (Lit_ArrayLhsOpen 'LD[') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\ '>) 
                              (word_part.EscapedLiteral
                                token: <Lit_EscapedChar '\\$'>
                              ) (Lit_RBracket ']') (Lit_Star '*')
                            }
                          ]
                          action: [
                            (command.ShAssignment
                              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:wl) op:Equal rhs:(word.Empty))]
                            )
                          ]
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$convenience'))})
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (C {(test)} {(-n)} 
                                          {(DQ ($ VSub_DollarName '$whole_archive_flag_spec'))}
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (C {(eval)} 
                                      {(Lit_VarLike 'tmp_whole_archive_flags=') 
                                        (word_part.EscapedLiteral
                                          token: <Lit_EscapedChar '\\"'>
                                        ) ($ VSub_DollarName '$whole_archive_flag_spec') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>)
                                      }
                                    )
                                    (command.AndOr
                                      ops: [Op_DPipe]
                                      children: [
                                        (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$wl'))})
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:tmp_whole_archive_flags)
                                              op: Equal
                                              rhs: 
                                                {
                                                  (command_sub
                                                    left_token: <Left_Backtick '`'>
                                                    command_list: 
                                                      (command.CommandList
                                                        children: [
                                                          (command.Pipeline
                                                            children: [
                                                              (C {($ VSub_DollarName '$ECHO')} 
                                                                {
                                                                  (DQ 
                                                                    ($ VSub_DollarName 
'$tmp_whole_archive_flags'
                                                                    )
                                                                  )
                                                                }
                                                              )
                                                              (C {($ VSub_DollarName '$SED')} 
                                                                {(SQ <'s|,| |g'>)}
                                                              )
                                                            ]
                                                            negated: F
                                                          )
                                                        ]
                                                      )
                                                  )
                                                }
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:reload_conv_objs)
                                          op: Equal
                                          rhs: 
                                            {($ VSub_DollarName '$reload_objs') 
                                              (word_part.EscapedLiteral
                                                token: <Lit_EscapedChar '\\ '>
                                              ) ($ VSub_DollarName '$tmp_whole_archive_flags')
                                            }
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                              else_action: [
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:gentop)
                                      op: Equal
                                      rhs: 
                                        {($ VSub_DollarName '$output_objdir') (/) (${ VSub_Name obj) 
                                          (x)
                                        }
                                    )
                                  ]
                                )
                                (C {(func_append)} {(generated)} 
                                  {(DQ (' ') ($ VSub_DollarName '$gentop'))}
                                )
                                (C {(func_extract_archives)} {($ VSub_DollarName '$gentop')} 
                                  {($ VSub_DollarName '$convenience')}
                                )
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:reload_conv_objs)
                                      op: Equal
                                      rhs: 
                                        {
                                          (DQ ($ VSub_DollarName '$reload_objs') (' ') 
                                            ($ VSub_DollarName '$func_extract_archives_result')
                                          )
                                        }
                                    )
                                  ]
                                )
                              ]
                            )
                          ]
                        )
                      ]
                    )
                    (command.AndOr
                      ops: [Op_DPipe]
                      children: [
                        (C {(test)} {(yes)} {(Lit_Equals '=')} 
                          {(DQ ($ VSub_DollarName '$build_libtool_libs'))}
                        )
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:libobjs)
                              op: Equal
                              rhs: {($ VSub_DollarName '$non_pic_objects')}
                            )
                          ]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:reload_objs)
                          op: Equal
                          rhs: 
                            {($ VSub_DollarName '$objs') ($ VSub_DollarName '$old_deplibs') (SQ <' '>) 
                              (command_sub
                                left_token: <Left_Backtick '`'>
                                command_list: 
                                  (command.CommandList
                                    children: [
                                      (command.Pipeline
                                        children: [
                                          (C {($ VSub_DollarName '$ECHO')} 
                                            {(DQ ($ VSub_DollarName '$libobjs'))}
                                          )
                                          (C {($ VSub_DollarName '$SP2NL')})
                                          (C {($ VSub_DollarName '$SED')} 
                                            {
                                              (DQ (/) (Lit_Other '\\') (.) ($ VSub_DollarName '$libext') 
                                                (Lit_Other '$') ('/d; /') (Lit_Other '\\') (.lib) (Lit_Other '$') ('/d; ') ($ VSub_DollarName '$lo2o')
                                              )
                                            }
                                          )
                                          (C {($ VSub_DollarName '$NL2SP')})
                                        ]
                                        negated: F
                                      )
                                    ]
                                  )
                              ) (SQ <' '>) ($ VSub_DollarName '$reload_conv_objs')
                            }
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:output)
                          op: Equal
                          rhs: {($ VSub_DollarName '$obj')}
                        )
                      ]
                    )
                    (C {(func_execute_cmds)} {(DQ ($ VSub_DollarName '$reload_cmds'))} {(SQ <'exit $?'>)})
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: (C {(test)} {(-z)} {(DQ ($ VSub_DollarName '$libobj'))})
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$gentop'))})
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [(C {(func_show_eval)} {(SQ <'${RM}r "$gentop"'>)})]
                                )
                              ]
                            )
                            (command.ControlFlow
                              token: <ControlFlow_Exit exit>
                              arg_word: {($ VSub_DollarName '$EXIT_SUCCESS')}
                            )
                          ]
                        )
                      ]
                    )
                    (command.AndOr
                      ops: [Op_DPipe]
                      children: [
                        (C {(test)} {(yes)} {(Lit_Equals '=')} 
                          {(DQ ($ VSub_DollarName '$build_libtool_libs'))}
                        )
                        (command.BraceGroup
                          children: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$gentop'))})
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [(C {(func_show_eval)} {(SQ <'${RM}r "$gentop"'>)})]
                                )
                              ]
                            )
                            (command.ControlFlow
                              token: <ControlFlow_Exit exit>
                              arg_word: {($ VSub_DollarName '$EXIT_SUCCESS')}
                            )
                          ]
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: 
                                (command.AndOr
                                  ops: [Op_DPipe]
                                  children: [
                                    (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$pic_flag'))})
                                    (C {(test)} {(default)} {(KW_Bang '!') (Lit_Equals '=')} 
                                      {(DQ ($ VSub_DollarName '$pic_mode'))}
                                    )
                                  ]
                                )
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:reload_objs)
                                  op: Equal
                                  rhs: 
                                    {
                                      (DQ ($ VSub_DollarName '$libobjs') (' ') 
                                        ($ VSub_DollarName '$reload_conv_objs')
                                      )
                                    }
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:output)
                                  op: Equal
                                  rhs: {($ VSub_DollarName '$libobj')}
                                )
                              ]
                            )
                            (C {(func_execute_cmds)} {(DQ ($ VSub_DollarName '$reload_cmds'))} 
                              {(SQ <'exit $?'>)}
                            )
                          ]
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$gentop'))})
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [(C {(func_show_eval)} {(SQ <'${RM}r "$gentop"'>)})]
                        )
                      ]
                    )
                    (command.ControlFlow
                      token: <ControlFlow_Exit exit>
                      arg_word: {($ VSub_DollarName '$EXIT_SUCCESS')}
                    )
                  ]
                )
                (case_arm
                  pat_list: [{(prog)}]
                  action: [
                    (command.Case
                      to_match: {($ VSub_DollarName '$host')}
                      arms: [
                        (case_arm
                          pat_list: [{(Lit_Star '*') (cygwin) (Lit_Star '*')}]
                          action: [
                            (C {(func_stripname)} {(SQ )} {(SQ <.exe>)} 
                              {(DQ ($ VSub_DollarName '$output'))}
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:output)
                                  op: Equal
                                  rhs: {($ VSub_DollarName '$func_stripname_result') (.exe)}
                                )
                              ]
                            )
                          ]
                        )
                      ]
                    )
                    (command.AndOr
                      ops: [Op_DAmp]
                      children: [
                        (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$vinfo'))})
                        (C {(func_warning)} {(DQ ("'-version-info' is ignored for programs"))})
                      ]
                    )
                    (command.AndOr
                      ops: [Op_DAmp]
                      children: [
                        (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$release'))})
                        (C {(func_warning)} {(DQ ("'-release' is ignored for programs"))})
                      ]
                    )
                    (command.AndOr
                      ops: [Op_DAmp Op_DAmp]
                      children: [
                        (C {($ VSub_DollarName '$preload')})
                        (C {(test)} {(unknown) (Lit_Comma ',') (unknown) (Lit_Comma ',') (unknown)} 
                          {(Lit_Equals '=')} 
                          {
                            (DQ ($ VSub_DollarName '$dlopen_support') (',') 
                              ($ VSub_DollarName '$dlopen_self') (',') ($ VSub_DollarName '$dlopen_self_static')
                            )
                          }
                        )
                        (C {(func_warning)} 
                          {(DQ ("'LT_INIT([dlopen])' not used. Assuming no dlopen support."))}
                        )
                      ]
                    )
                    (command.Case
                      to_match: {($ VSub_DollarName '$host')}
                      arms: [
                        (case_arm
                          pat_list: [
                            {(Lit_Star '*') (-) (Lit_Star '*') (-rhapsody) (Lit_Star '*')}
                            {(Lit_Star '*') (-) (Lit_Star '*') (-darwin1.) (Lit_LBracket '[') (012) 
                              (Lit_RBracket ']')
                            }
                          ]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:compile_deplibs)
                                  op: Equal
                                  rhs: 
                                    {
                                      (command_sub
                                        left_token: <Left_Backtick '`'>
                                        command_list: 
                                          (command.CommandList
                                            children: [
                                              (command.Pipeline
                                                children: [
                                                  (C {($ VSub_DollarName '$ECHO')} 
                                                    {
                                                      (DQ (' ') ($ VSub_DollarName '$compile_deplibs'))
                                                    }
                                                  )
                                                  (C {($ VSub_DollarName '$SED')} 
                                                    {(SQ <'s/ -lc / System.ltframework /'>)}
                                                  )
                                                ]
                                                negated: F
                                              )
                                            ]
                                          )
                                      )
                                    }
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:finalize_deplibs)
                                  op: Equal
                                  rhs: 
                                    {
                                      (command_sub
                                        left_token: <Left_Backtick '`'>
                                        command_list: 
                                          (command.CommandList
                                            children: [
                                              (command.Pipeline
                                                children: [
                                                  (C {($ VSub_DollarName '$ECHO')} 
                                                    {
                                                      (DQ (' ') 
                                                        ($ VSub_DollarName '$finalize_deplibs')
                                                      )
                                                    }
                                                  )
                                                  (C {($ VSub_DollarName '$SED')} 
                                                    {(SQ <'s/ -lc / System.ltframework /'>)}
                                                  )
                                                ]
                                                negated: F
                                              )
                                            ]
                                          )
                                      )
                                    }
                                )
                              ]
                            )
                          ]
                        )
                      ]
                    )
                    (command.Case
                      to_match: {($ VSub_DollarName '$host')}
                      arms: [
                        (case_arm
                          pat_list: [{(Lit_Star '*') (-) (Lit_Star '*') (-darwin) (Lit_Star '*')}]
                          action: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (C {(test)} {(CXX)} {(Lit_Equals '=')} 
                                          {(DQ ($ VSub_DollarName '$tagname'))}
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (command.Case
                                      to_match: 
                                        {
                                          (braced_var_sub
                                            token: <VSub_Name MACOSX_DEPLOYMENT_TARGET>
                                            suffix_op: 
                                              (suffix_op.Unary
                                                op_id: VTest_Hyphen
                                                arg_word: {(10.0)}
                                              )
                                          )
                                        }
                                      arms: [
                                        (case_arm
                                          pat_list: [
                                            {(10.) (Lit_LBracket '[') (0123) (Lit_RBracket ']')}
                                          ]
                                          action: [
                                            (C {(func_append)} {(compile_command)} 
                                              {(DQ (' ') ($ VSub_DollarName '$wl') (-bind_at_load))}
                                            )
                                            (C {(func_append)} {(finalize_command)} 
                                              {(DQ (' ') ($ VSub_DollarName '$wl') (-bind_at_load))}
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:compile_deplibs)
                                  op: Equal
                                  rhs: 
                                    {
                                      (command_sub
                                        left_token: <Left_Backtick '`'>
                                        command_list: 
                                          (command.CommandList
                                            children: [
                                              (command.Pipeline
                                                children: [
                                                  (C {($ VSub_DollarName '$ECHO')} 
                                                    {
                                                      (DQ (' ') ($ VSub_DollarName '$compile_deplibs'))
                                                    }
                                                  )
                                                  (C {($ VSub_DollarName '$SED')} 
                                                    {
                                                      (SQ 
                                                        <
's% \\([^ $]*\\).ltframework% -framework \\1%g'
                                                        >
                                                      )
                                                    }
                                                  )
                                                ]
                                                negated: F
                                              )
                                            ]
                                          )
                                      )
                                    }
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:finalize_deplibs)
                                  op: Equal
                                  rhs: 
                                    {
                                      (command_sub
                                        left_token: <Left_Backtick '`'>
                                        command_list: 
                                          (command.CommandList
                                            children: [
                                              (command.Pipeline
                                                children: [
                                                  (C {($ VSub_DollarName '$ECHO')} 
                                                    {
                                                      (DQ (' ') 
                                                        ($ VSub_DollarName '$finalize_deplibs')
                                                      )
                                                    }
                                                  )
                                                  (C {($ VSub_DollarName '$SED')} 
                                                    {
                                                      (SQ 
                                                        <
's% \\([^ $]*\\).ltframework% -framework \\1%g'
                                                        >
                                                      )
                                                    }
                                                  )
                                                ]
                                                negated: F
                                              )
                                            ]
                                          )
                                      )
                                    }
                                )
                              ]
                            )
                          ]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:new_libs) op:Equal rhs:(word.Empty))]
                    )
                    (command.ForEach
                      iter_name: path
                      iter_words: [{($ VSub_DollarName '$notinst_path')}]
                      do_arg_iter: F
                      body: 
                        (command.DoGroup
                          children: [
                            (command.Case
                              to_match: {(DQ (' ') ($ VSub_DollarName '$new_libs') (' '))}
                              arms: [
                                (case_arm
                                  pat_list: [
                                    {(Lit_Star '*') 
                                      (DQ (' -L') ($ VSub_DollarName '$path') (/) 
                                        ($ VSub_DollarName '$objdir') (' ')
                                      ) (Lit_Star '*')
                                    }
                                  ]
                                )
                                (case_arm
                                  pat_list: [{(Lit_Star '*')}]
                                  action: [
                                    (command.Case
                                      to_match: 
                                        {(DQ (' ') ($ VSub_DollarName '$compile_deplibs') (' '))}
                                      arms: [
                                        (case_arm
                                          pat_list: [
                                            {(Lit_Star '*') 
                                              (DQ (' -L') ($ VSub_DollarName '$path') (/) 
                                                ($ VSub_DollarName '$objdir') (' ')
                                              ) (Lit_Star '*')
                                            }
                                          ]
                                          action: [
                                            (C {(func_append)} {(new_libs)} 
                                              {
                                                (DQ (' -L') ($ VSub_DollarName '$path') (/) 
                                                  ($ VSub_DollarName '$objdir')
                                                )
                                              }
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                            )
                          ]
                        )
                    )
                    (command.ForEach
                      iter_name: deplib
                      iter_words: [{($ VSub_DollarName '$compile_deplibs')}]
                      do_arg_iter: F
                      body: 
                        (command.DoGroup
                          children: [
                            (command.Case
                              to_match: {($ VSub_DollarName '$deplib')}
                              arms: [
                                (case_arm
                                  pat_list: [{(-L) (Lit_Star '*')}]
                                  action: [
                                    (command.Case
                                      to_match: {(DQ (' ') ($ VSub_DollarName '$new_libs') (' '))}
                                      arms: [
                                        (case_arm
                                          pat_list: [
                                            {(Lit_Star '*') 
                                              (DQ (' ') ($ VSub_DollarName '$deplib') (' ')) (Lit_Star '*')
                                            }
                                          ]
                                        )
                                        (case_arm
                                          pat_list: [{(Lit_Star '*')}]
                                          action: [
                                            (C {(func_append)} {(new_libs)} 
                                              {(DQ (' ') ($ VSub_DollarName '$deplib'))}
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                  ]
                                )
                                (case_arm
                                  pat_list: [{(Lit_Star '*')}]
                                  action: [
                                    (C {(func_append)} {(new_libs)} 
                                      {(DQ (' ') ($ VSub_DollarName '$deplib'))}
                                    )
                                  ]
                                )
                              ]
                            )
                          ]
                        )
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:compile_deplibs)
                          op: Equal
                          rhs: {($ VSub_DollarName '$new_libs')}
                        )
                      ]
                    )
                    (C {(func_append)} {(compile_command)} 
                      {(DQ (' ') ($ VSub_DollarName '$compile_deplibs'))}
                    )
                    (C {(func_append)} {(finalize_command)} 
                      {(DQ (' ') ($ VSub_DollarName '$finalize_deplibs'))}
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: 
                                (C {(test)} {(-n)} 
                                  {(DQ ($ VSub_DollarName '$rpath') ($ VSub_DollarName '$xrpath'))}
                                )
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [
                            (command.ForEach
                              iter_name: libdir
                              iter_words: [
                                {($ VSub_DollarName '$rpath')}
                                {($ VSub_DollarName '$xrpath')}
                              ]
                              do_arg_iter: F
                              body: 
                                (command.DoGroup
                                  children: [
                                    (command.Case
                                      to_match: {(DQ ($ VSub_DollarName '$finalize_rpath') (' '))}
                                      arms: [
                                        (case_arm
                                          pat_list: [
                                            {(Lit_Star '*') 
                                              (DQ (' ') ($ VSub_DollarName '$libdir') (' ')) (Lit_Star '*')
                                            }
                                          ]
                                        )
                                        (case_arm
                                          pat_list: [{(Lit_Star '*')}]
                                          action: [
                                            (C {(func_append)} {(finalize_rpath)} 
                                              {(DQ (' ') ($ VSub_DollarName '$libdir'))}
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                  ]
                                )
                            )
                          ]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:rpath) op:Equal rhs:(word.Empty))]
                    )
                    (command.ShAssignment
                      pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:hardcode_libdirs) op:Equal rhs:(word.Empty))]
                    )
                    (command.ForEach
                      iter_name: libdir
                      iter_words: [
                        {($ VSub_DollarName '$compile_rpath')}
                        {($ VSub_DollarName '$finalize_rpath')}
                      ]
                      do_arg_iter: F
                      body: 
                        (command.DoGroup
                          children: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (C {(test)} {(-n)} 
                                          {(DQ ($ VSub_DollarName '$hardcode_libdir_flag_spec'))}
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (command.Sentence
                                              child: 
                                                (C {(test)} {(-n)} 
                                                  {
                                                    (DQ 
                                                      ($ VSub_DollarName '$hardcode_libdir_separator')
                                                    )
                                                  }
                                                )
                                              terminator: <Op_Semi ';'>
                                            )
                                          ]
                                          action: [
                                            (command.If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (command.Sentence
                                                      child: 
                                                        (C {(test)} {(-z)} 
                                                          {
                                                            (DQ 
                                                              ($ VSub_DollarName '$hardcode_libdirs')
                                                            )
                                                          }
                                                        )
                                                      terminator: <Op_Semi ';'>
                                                    )
                                                  ]
                                                  action: [
                                                    (command.ShAssignment
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: 
                                                            (sh_lhs_expr.Name
                                                              name: hardcode_libdirs
                                                            )
                                                          op: Equal
                                                          rhs: {($ VSub_DollarName '$libdir')}
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                )
                                              ]
                                              else_action: [
                                                (command.Case
                                                  to_match: 
                                                    {
                                                      ($ VSub_DollarName '$hardcode_libdir_separator') ($ VSub_DollarName '$hardcode_libdirs') ($ VSub_DollarName '$hardcode_libdir_separator')
                                                    }
                                                  arms: [
                                                    (case_arm
                                                      pat_list: [
                                                        {(Lit_Star '*') 
                                                          (DQ 
                                                            ($ VSub_DollarName 
'$hardcode_libdir_separator'
                                                            ) ($ VSub_DollarName '$libdir') ($ VSub_DollarName '$hardcode_libdir_separator')
                                                          ) (Lit_Star '*')
                                                        }
                                                      ]
                                                    )
                                                    (case_arm
                                                      pat_list: [{(Lit_Star '*')}]
                                                      action: [
                                                        (C {(func_append)} {(hardcode_libdirs)} 
                                                          {
                                                            (DQ 
                                                              ($ VSub_DollarName 
'$hardcode_libdir_separator'
                                                              ) ($ VSub_DollarName '$libdir')
                                                            )
                                                          }
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                      ]
                                      else_action: [
                                        (C {(eval)} 
                                          {(Lit_VarLike 'flag=') 
                                            (word_part.EscapedLiteral
                                              token: <Lit_EscapedChar '\\"'>
                                            ) ($ VSub_DollarName '$hardcode_libdir_flag_spec') 
                                            (word_part.EscapedLiteral
                                              token: <Lit_EscapedChar '\\"'>
                                            )
                                          }
                                        )
                                        (C {(func_append)} {(rpath)} 
                                          {(DQ (' ') ($ VSub_DollarName '$flag'))}
                                        )
                                      ]
                                    )
                                  ]
                                )
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$runpath_var'))})
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (command.Case
                                      to_match: {(DQ ($ VSub_DollarName '$perm_rpath') (' '))}
                                      arms: [
                                        (case_arm
                                          pat_list: [
                                            {(Lit_Star '*') 
                                              (DQ (' ') ($ VSub_DollarName '$libdir') (' ')) (Lit_Star '*')
                                            }
                                          ]
                                        )
                                        (case_arm
                                          pat_list: [{(Lit_Star '*')}]
                                          action: [
                                            (C {(func_append)} {(perm_rpath)} 
                                              {(DQ (' ') ($ VSub_DollarName '$libdir'))}
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.Case
                              to_match: {($ VSub_DollarName '$host')}
                              arms: [
                                (case_arm
                                  pat_list: [
                                    {(Lit_Star '*') (-) (Lit_Star '*') (-cygwin) (Lit_Star '*')}
                                    {(Lit_Star '*') (-) (Lit_Star '*') (-mingw) (Lit_Star '*')}
                                    {(Lit_Star '*') (-) (Lit_Star '*') (-pw32) (Lit_Star '*')}
                                    {(Lit_Star '*') (-) (Lit_Star '*') (-os2) (Lit_Star '*')}
                                    {(Lit_Star '*') (-cegcc) (Lit_Star '*')}
                                  ]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:testbindir)
                                          op: Equal
                                          rhs: 
                                            {
                                              (command_sub
                                                left_token: <Left_Backtick '`'>
                                                command_list: 
                                                  (command.CommandList
                                                    children: [
                                                      (command.Pipeline
                                                        children: [
                                                          (C {($ VSub_DollarName '$ECHO')} 
                                                            {(DQ ($ VSub_DollarName '$libdir'))}
                                                          )
                                                          (C {($ VSub_DollarName '$SED')} {(-e)} 
                                                            {(SQ <'s*/lib$*/bin*'>)}
                                                          )
                                                        ]
                                                        negated: F
                                                      )
                                                    ]
                                                  )
                                              )
                                            }
                                        )
                                      ]
                                    )
                                    (command.Case
                                      to_match: 
                                        {(Lit_Other ':') ($ VSub_DollarName '$dllsearchpath') 
                                          (Lit_Other ':')
                                        }
                                      arms: [
                                        (case_arm
                                          pat_list: [
                                            {(Lit_Star '*') 
                                              (DQ (':') ($ VSub_DollarName '$libdir') (':')) (Lit_Star '*')
                                            }
                                          ]
                                        )
                                        (case_arm
                                          pat_list: [{(Lit_Other ':') (Lit_Other ':')}]
                                          action: [
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:dllsearchpath)
                                                  op: Equal
                                                  rhs: {($ VSub_DollarName '$libdir')}
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                        (case_arm
                                          pat_list: [{(Lit_Star '*')}]
                                          action: [
                                            (C {(func_append)} {(dllsearchpath)} 
                                              {(DQ (':') ($ VSub_DollarName '$libdir'))}
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                    (command.Case
                                      to_match: 
                                        {(Lit_Other ':') ($ VSub_DollarName '$dllsearchpath') 
                                          (Lit_Other ':')
                                        }
                                      arms: [
                                        (case_arm
                                          pat_list: [
                                            {(Lit_Star '*') 
                                              (DQ (':') ($ VSub_DollarName '$testbindir') (':')) (Lit_Star '*')
                                            }
                                          ]
                                        )
                                        (case_arm
                                          pat_list: [{(Lit_Other ':') (Lit_Other ':')}]
                                          action: [
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:dllsearchpath)
                                                  op: Equal
                                                  rhs: {($ VSub_DollarName '$testbindir')}
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                        (case_arm
                                          pat_list: [{(Lit_Star '*')}]
                                          action: [
                                            (C {(func_append)} {(dllsearchpath)} 
                                              {(DQ (':') ($ VSub_DollarName '$testbindir'))}
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                            )
                          ]
                        )
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: 
                                (command.AndOr
                                  ops: [Op_DAmp]
                                  children: [
                                    (C {(test)} {(-n)} 
                                      {(DQ ($ VSub_DollarName '$hardcode_libdir_separator'))}
                                    )
                                    (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$hardcode_libdirs'))})
                                  ]
                                )
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:libdir)
                                  op: Equal
                                  rhs: {($ VSub_DollarName '$hardcode_libdirs')}
                                )
                              ]
                            )
                            (C {(eval)} 
                              {(Lit_VarLike 'rpath=') 
                                (word_part.EscapedLiteral
                                  token: <Lit_EscapedChar '\\"'>
                                )
                              } 
                              {($ VSub_DollarName '$hardcode_libdir_flag_spec') 
                                (word_part.EscapedLiteral
                                  token: <Lit_EscapedChar '\\"'>
                                )
                              }
                            )
                          ]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:compile_rpath)
                          op: Equal
                          rhs: {($ VSub_DollarName '$rpath')}
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:rpath) op:Equal rhs:(word.Empty))]
                    )
                    (command.ShAssignment
                      pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:hardcode_libdirs) op:Equal rhs:(word.Empty))]
                    )
                    (command.ForEach
                      iter_name: libdir
                      iter_words: [{($ VSub_DollarName '$finalize_rpath')}]
                      do_arg_iter: F
                      body: 
                        (command.DoGroup
                          children: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (C {(test)} {(-n)} 
                                          {(DQ ($ VSub_DollarName '$hardcode_libdir_flag_spec'))}
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (command.Sentence
                                              child: 
                                                (C {(test)} {(-n)} 
                                                  {
                                                    (DQ 
                                                      ($ VSub_DollarName '$hardcode_libdir_separator')
                                                    )
                                                  }
                                                )
                                              terminator: <Op_Semi ';'>
                                            )
                                          ]
                                          action: [
                                            (command.If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (command.Sentence
                                                      child: 
                                                        (C {(test)} {(-z)} 
                                                          {
                                                            (DQ 
                                                              ($ VSub_DollarName '$hardcode_libdirs')
                                                            )
                                                          }
                                                        )
                                                      terminator: <Op_Semi ';'>
                                                    )
                                                  ]
                                                  action: [
                                                    (command.ShAssignment
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: 
                                                            (sh_lhs_expr.Name
                                                              name: hardcode_libdirs
                                                            )
                                                          op: Equal
                                                          rhs: {($ VSub_DollarName '$libdir')}
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                )
                                              ]
                                              else_action: [
                                                (command.Case
                                                  to_match: 
                                                    {
                                                      ($ VSub_DollarName '$hardcode_libdir_separator') ($ VSub_DollarName '$hardcode_libdirs') ($ VSub_DollarName '$hardcode_libdir_separator')
                                                    }
                                                  arms: [
                                                    (case_arm
                                                      pat_list: [
                                                        {(Lit_Star '*') 
                                                          (DQ 
                                                            ($ VSub_DollarName 
'$hardcode_libdir_separator'
                                                            ) ($ VSub_DollarName '$libdir') ($ VSub_DollarName '$hardcode_libdir_separator')
                                                          ) (Lit_Star '*')
                                                        }
                                                      ]
                                                    )
                                                    (case_arm
                                                      pat_list: [{(Lit_Star '*')}]
                                                      action: [
                                                        (C {(func_append)} {(hardcode_libdirs)} 
                                                          {
                                                            (DQ 
                                                              ($ VSub_DollarName 
'$hardcode_libdir_separator'
                                                              ) ($ VSub_DollarName '$libdir')
                                                            )
                                                          }
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                      ]
                                      else_action: [
                                        (C {(eval)} 
                                          {(Lit_VarLike 'flag=') 
                                            (word_part.EscapedLiteral
                                              token: <Lit_EscapedChar '\\"'>
                                            ) ($ VSub_DollarName '$hardcode_libdir_flag_spec') 
                                            (word_part.EscapedLiteral
                                              token: <Lit_EscapedChar '\\"'>
                                            )
                                          }
                                        )
                                        (C {(func_append)} {(rpath)} 
                                          {(DQ (' ') ($ VSub_DollarName '$flag'))}
                                        )
                                      ]
                                    )
                                  ]
                                )
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$runpath_var'))})
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (command.Case
                                      to_match: {(DQ ($ VSub_DollarName '$finalize_perm_rpath') (' '))}
                                      arms: [
                                        (case_arm
                                          pat_list: [
                                            {(Lit_Star '*') 
                                              (DQ (' ') ($ VSub_DollarName '$libdir') (' ')) (Lit_Star '*')
                                            }
                                          ]
                                        )
                                        (case_arm
                                          pat_list: [{(Lit_Star '*')}]
                                          action: [
                                            (C {(func_append)} {(finalize_perm_rpath)} 
                                              {(DQ (' ') ($ VSub_DollarName '$libdir'))}
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                            )
                          ]
                        )
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: 
                                (command.AndOr
                                  ops: [Op_DAmp]
                                  children: [
                                    (C {(test)} {(-n)} 
                                      {(DQ ($ VSub_DollarName '$hardcode_libdir_separator'))}
                                    )
                                    (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$hardcode_libdirs'))})
                                  ]
                                )
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:libdir)
                                  op: Equal
                                  rhs: {($ VSub_DollarName '$hardcode_libdirs')}
                                )
                              ]
                            )
                            (C {(eval)} 
                              {(Lit_VarLike 'rpath=') 
                                (word_part.EscapedLiteral
                                  token: <Lit_EscapedChar '\\"'>
                                )
                              } 
                              {($ VSub_DollarName '$hardcode_libdir_flag_spec') 
                                (word_part.EscapedLiteral
                                  token: <Lit_EscapedChar '\\"'>
                                )
                              }
                            )
                          ]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:finalize_rpath)
                          op: Equal
                          rhs: {($ VSub_DollarName '$rpath')}
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: 
                                (command.AndOr
                                  ops: [Op_DAmp]
                                  children: [
                                    (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$libobjs'))})
                                    (C {(test)} {(yes)} {(Lit_Equals '=')} 
                                      {(DQ ($ VSub_DollarName '$build_old_libs'))}
                                    )
                                  ]
                                )
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:compile_command)
                                  op: Equal
                                  rhs: 
                                    {
                                      (command_sub
                                        left_token: <Left_Backtick '`'>
                                        command_list: 
                                          (command.CommandList
                                            children: [
                                              (command.Pipeline
                                                children: [
                                                  (C {($ VSub_DollarName '$ECHO')} 
                                                    {(DQ ($ VSub_DollarName '$compile_command'))}
                                                  )
                                                  (C {($ VSub_DollarName '$SP2NL')})
                                                  (C {($ VSub_DollarName '$SED')} 
                                                    {(DQ ($ VSub_DollarName '$lo2o'))}
                                                  )
                                                  (C {($ VSub_DollarName '$NL2SP')})
                                                ]
                                                negated: F
                                              )
                                            ]
                                          )
                                      )
                                    }
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:finalize_command)
                                  op: Equal
                                  rhs: 
                                    {
                                      (command_sub
                                        left_token: <Left_Backtick '`'>
                                        command_list: 
                                          (command.CommandList
                                            children: [
                                              (command.Pipeline
                                                children: [
                                                  (C {($ VSub_DollarName '$ECHO')} 
                                                    {(DQ ($ VSub_DollarName '$finalize_command'))}
                                                  )
                                                  (C {($ VSub_DollarName '$SP2NL')})
                                                  (C {($ VSub_DollarName '$SED')} 
                                                    {(DQ ($ VSub_DollarName '$lo2o'))}
                                                  )
                                                  (C {($ VSub_DollarName '$NL2SP')})
                                                ]
                                                negated: F
                                              )
                                            ]
                                          )
                                      )
                                    }
                                )
                              ]
                            )
                          ]
                        )
                      ]
                    )
                    (C {(func_generate_dlsyms)} {(DQ ($ VSub_DollarName '$outputname'))} 
                      {(DQ ('@PROGRAM@'))} {(false)}
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$prelink_cmds'))})
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [
                            (C {(func_execute_cmds)} {(DQ ($ VSub_DollarName '$prelink_cmds'))} 
                              {(SQ <'exit $?'>)}
                            )
                          ]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:wrappers_required)
                          op: Equal
                          rhs: {(Lit_Other ':')}
                        )
                      ]
                    )
                    (command.Case
                      to_match: {($ VSub_DollarName '$host')}
                      arms: [
                        (case_arm
                          pat_list: [
                            {(Lit_Star '*') (cegcc) (Lit_Star '*')}
                            {(Lit_Star '*') (mingw32ce) (Lit_Star '*')}
                          ]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:wrappers_required)
                                  op: Equal
                                  rhs: {(false)}
                                )
                              ]
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [
                            {(Lit_Star '*') (cygwin) (Lit_Star '*')}
                            {(Lit_Star '*') (mingw) (Lit_Star '*')}
                          ]
                          action: [
                            (command.AndOr
                              ops: [Op_DPipe]
                              children: [
                                (C {(test)} {(yes)} {(Lit_Equals '=')} 
                                  {(DQ ($ VSub_DollarName '$build_libtool_libs'))}
                                )
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:wrappers_required)
                                      op: Equal
                                      rhs: {(false)}
                                    )
                                  ]
                                )
                              ]
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(Lit_Star '*')}]
                          action: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (command.AndOr
                                          ops: [Op_DPipe]
                                          children: [
                                            (C {(test)} {(no)} {(Lit_Equals '=')} 
                                              {(DQ ($ VSub_DollarName '$need_relink'))}
                                            )
                                            (C {(test)} {(yes)} {(KW_Bang '!') (Lit_Equals '=')} 
                                              {(DQ ($ VSub_DollarName '$build_libtool_libs'))}
                                            )
                                          ]
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:wrappers_required)
                                          op: Equal
                                          rhs: {(false)}
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                            )
                          ]
                        )
                      ]
                    )
                    (command.AndOr
                      ops: [Op_DPipe]
                      children: [
                        (C {($ VSub_DollarName '$wrappers_required')})
                        (command.BraceGroup
                          children: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:compile_command)
                                  op: Equal
                                  rhs: 
                                    {
                                      (command_sub
                                        left_token: <Left_Backtick '`'>
                                        command_list: 
                                          (command.CommandList
                                            children: [
                                              (command.Pipeline
                                                children: [
                                                  (C {($ VSub_DollarName '$ECHO')} 
                                                    {(DQ ($ VSub_DollarName '$compile_command'))}
                                                  )
                                                  (C {($ VSub_DollarName '$SED')} 
                                                    {(SQ <'s%@OUTPUT@%'>) 
                                                      (DQ ($ VSub_DollarName '$output')) (SQ <'%g'>)
                                                    }
                                                  )
                                                ]
                                                negated: F
                                              )
                                            ]
                                          )
                                      )
                                    }
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:link_command)
                                  op: Equal
                                  rhs: 
                                    {($ VSub_DollarName '$compile_command') 
                                      ($ VSub_DollarName '$compile_rpath')
                                    }
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:exit_status)
                                  op: Equal
                                  rhs: {(0)}
                                )
                              ]
                            )
                            (C {(func_show_eval)} {(DQ ($ VSub_DollarName '$link_command'))} 
                              {(SQ <'exit_status=$?'>)}
                            )
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$postlink_cmds'))})
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (C {(func_to_tool_file)} {(DQ ($ VSub_DollarName '$output'))})
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:postlink_cmds)
                                          op: Equal
                                          rhs: 
                                            {
                                              (command_sub
                                                left_token: <Left_Backtick '`'>
                                                command_list: 
                                                  (command.CommandList
                                                    children: [
                                                      (command.Pipeline
                                                        children: [
                                                          (C {(func_echo_all)} 
                                                            {
                                                              (DQ 
                                                                ($ VSub_DollarName '$postlink_cmds')
                                                              )
                                                            }
                                                          )
                                                          (C {($ VSub_DollarName '$SED')} {(-e)} 
                                                            {(SQ <'s%@OUTPUT@%'>) 
                                                              (DQ ($ VSub_DollarName '$output')) (SQ <'%g'>)
                                                            } {(-e)} {(SQ <'s%@TOOL_OUTPUT@%'>) (DQ ($ VSub_DollarName '$func_to_tool_file_result')) (SQ <'%g'>)}
                                                          )
                                                        ]
                                                        negated: F
                                                      )
                                                    ]
                                                  )
                                              )
                                            }
                                        )
                                      ]
                                    )
                                    (C {(func_execute_cmds)} {(DQ ($ VSub_DollarName '$postlink_cmds'))} 
                                      {(SQ <'exit $?'>)}
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (C {(test)} {(-f)} 
                                          {
                                            (DQ ($ VSub_DollarName '$output_objdir') (/) 
                                              (${ VSub_Name outputname) (S.) ($ VSub_DollarName '$objext')
                                            )
                                          }
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (C {(func_show_eval)} 
                                      {(SQ <'$RM "$output_objdir/${outputname}S.$objext"'>)}
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.ControlFlow
                              token: <ControlFlow_Exit exit>
                              arg_word: {($ VSub_DollarName '$exit_status')}
                            )
                          ]
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: 
                                (C {(test)} {(-n)} 
                                  {
                                    (DQ ($ VSub_DollarName '$compile_shlibpath') 
                                      ($ VSub_DollarName '$finalize_shlibpath')
                                    )
                                  }
                                )
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:compile_command)
                                  op: Equal
                                  rhs: 
                                    {
                                      (DQ ($ VSub_DollarName '$shlibpath_var') ('=') 
                                        (word_part.EscapedLiteral
                                          token: <Lit_EscapedChar '\\"'>
                                        ) ($ VSub_DollarName '$compile_shlibpath') ($ VSub_DollarName '$finalize_shlibpath') 
                                        (word_part.EscapedLiteral
                                          token: <Lit_EscapedChar '\\$'>
                                        ) ($ VSub_DollarName '$shlibpath_var') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) (' ') 
                                        ($ VSub_DollarName '$compile_command')
                                      )
                                    }
                                )
                              ]
                            )
                          ]
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: 
                                (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$finalize_shlibpath'))})
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:finalize_command)
                                  op: Equal
                                  rhs: 
                                    {
                                      (DQ ($ VSub_DollarName '$shlibpath_var') ('=') 
                                        (word_part.EscapedLiteral
                                          token: <Lit_EscapedChar '\\"'>
                                        ) ($ VSub_DollarName '$finalize_shlibpath') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) 
                                        ($ VSub_DollarName '$shlibpath_var') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) (' ') ($ VSub_DollarName '$finalize_command')
                                      )
                                    }
                                )
                              ]
                            )
                          ]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:compile_var) op:Equal rhs:(word.Empty))]
                    )
                    (command.ShAssignment
                      pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:finalize_var) op:Equal rhs:(word.Empty))]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$runpath_var'))})
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$perm_rpath'))})
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:rpath)
                                          op: Equal
                                          rhs: (word.Empty)
                                        )
                                      ]
                                    )
                                    (command.ForEach
                                      iter_name: dir
                                      iter_words: [{($ VSub_DollarName '$perm_rpath')}]
                                      do_arg_iter: F
                                      body: 
                                        (command.DoGroup
                                          children: [
                                            (C {(func_append)} {(rpath)} 
                                              {(DQ ($ VSub_DollarName '$dir') (':'))}
                                            )
                                          ]
                                        )
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:compile_var)
                                          op: Equal
                                          rhs: 
                                            {
                                              (DQ ($ VSub_DollarName '$runpath_var') ('=') 
                                                (word_part.EscapedLiteral
                                                  token: <Lit_EscapedChar '\\"'>
                                                ) ($ VSub_DollarName '$rpath') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) 
                                                ($ VSub_DollarName '$runpath_var') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) (' ')
                                              )
                                            }
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (C {(test)} {(-n)} 
                                          {(DQ ($ VSub_DollarName '$finalize_perm_rpath'))}
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:rpath)
                                          op: Equal
                                          rhs: (word.Empty)
                                        )
                                      ]
                                    )
                                    (command.ForEach
                                      iter_name: dir
                                      iter_words: [{($ VSub_DollarName '$finalize_perm_rpath')}]
                                      do_arg_iter: F
                                      body: 
                                        (command.DoGroup
                                          children: [
                                            (C {(func_append)} {(rpath)} 
                                              {(DQ ($ VSub_DollarName '$dir') (':'))}
                                            )
                                          ]
                                        )
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:finalize_var)
                                          op: Equal
                                          rhs: 
                                            {
                                              (DQ ($ VSub_DollarName '$runpath_var') ('=') 
                                                (word_part.EscapedLiteral
                                                  token: <Lit_EscapedChar '\\"'>
                                                ) ($ VSub_DollarName '$rpath') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) 
                                                ($ VSub_DollarName '$runpath_var') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) (' ')
                                              )
                                            }
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                            )
                          ]
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: 
                                (C {(test)} {(yes)} {(Lit_Equals '=')} 
                                  {(DQ ($ VSub_DollarName '$no_install'))}
                                )
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:link_command)
                                  op: Equal
                                  rhs: 
                                    {($ VSub_DollarName '$compile_var') 
                                      ($ VSub_DollarName '$compile_command') ($ VSub_DollarName '$compile_rpath')
                                    }
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:link_command)
                                  op: Equal
                                  rhs: 
                                    {
                                      (command_sub
                                        left_token: <Left_Backtick '`'>
                                        command_list: 
                                          (command.CommandList
                                            children: [
                                              (command.Pipeline
                                                children: [
                                                  (C {($ VSub_DollarName '$ECHO')} 
                                                    {(DQ ($ VSub_DollarName '$link_command'))}
                                                  )
                                                  (C {($ VSub_DollarName '$SED')} 
                                                    {(SQ <'s%@OUTPUT@%'>) 
                                                      (DQ ($ VSub_DollarName '$output')) (SQ <'%g'>)
                                                    }
                                                  )
                                                ]
                                                negated: F
                                              )
                                            ]
                                          )
                                      )
                                    }
                                )
                              ]
                            )
                            (command.AndOr
                              ops: [Op_DPipe]
                              children: [
                                (C {($ VSub_DollarName '$opt_dry_run')})
                                (C {($ VSub_DollarName '$RM')} {($ VSub_DollarName '$output')})
                              ]
                            )
                            (C {(func_show_eval)} {(DQ ($ VSub_DollarName '$link_command'))} 
                              {(SQ <'exit $?'>)}
                            )
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$postlink_cmds'))})
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (C {(func_to_tool_file)} {(DQ ($ VSub_DollarName '$output'))})
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:postlink_cmds)
                                          op: Equal
                                          rhs: 
                                            {
                                              (command_sub
                                                left_token: <Left_Backtick '`'>
                                                command_list: 
                                                  (command.CommandList
                                                    children: [
                                                      (command.Pipeline
                                                        children: [
                                                          (C {(func_echo_all)} 
                                                            {
                                                              (DQ 
                                                                ($ VSub_DollarName '$postlink_cmds')
                                                              )
                                                            }
                                                          )
                                                          (C {($ VSub_DollarName '$SED')} {(-e)} 
                                                            {(SQ <'s%@OUTPUT@%'>) 
                                                              (DQ ($ VSub_DollarName '$output')) (SQ <'%g'>)
                                                            } {(-e)} {(SQ <'s%@TOOL_OUTPUT@%'>) (DQ ($ VSub_DollarName '$func_to_tool_file_result')) (SQ <'%g'>)}
                                                          )
                                                        ]
                                                        negated: F
                                                      )
                                                    ]
                                                  )
                                              )
                                            }
                                        )
                                      ]
                                    )
                                    (C {(func_execute_cmds)} {(DQ ($ VSub_DollarName '$postlink_cmds'))} 
                                      {(SQ <'exit $?'>)}
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.ControlFlow
                              token: <ControlFlow_Exit exit>
                              arg_word: {($ VSub_DollarName '$EXIT_SUCCESS')}
                            )
                          ]
                        )
                      ]
                    )
                    (command.Case
                      to_match: 
                        {($ VSub_DollarName '$hardcode_action') (Lit_Comma ',') 
                          ($ VSub_DollarName '$fast_install')
                        }
                      arms: [
                        (case_arm
                          pat_list: [{(relink) (Lit_Comma ',') (Lit_Star '*')}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:link_command)
                                  op: Equal
                                  rhs: 
                                    {($ VSub_DollarName '$compile_var') 
                                      ($ VSub_DollarName '$compile_command') ($ VSub_DollarName '$compile_rpath')
                                    }
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:relink_command)
                                  op: Equal
                                  rhs: 
                                    {($ VSub_DollarName '$finalize_var') 
                                      ($ VSub_DollarName '$finalize_command') ($ VSub_DollarName '$finalize_rpath')
                                    }
                                )
                              ]
                            )
                            (C {(func_warning)} 
                              {(DQ ('this platform does not like uninstalled shared libraries'))}
                            )
                            (C {(func_warning)} 
                              {
                                (DQ ("'") ($ VSub_DollarName '$output') 
                                  ("' will be relinked during installation")
                                )
                              }
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(Lit_Star '*') (Lit_Comma ',') (yes)}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:link_command)
                                  op: Equal
                                  rhs: 
                                    {($ VSub_DollarName '$finalize_var') 
                                      ($ VSub_DollarName '$compile_command') ($ VSub_DollarName '$finalize_rpath')
                                    }
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:relink_command)
                                  op: Equal
                                  rhs: 
                                    {
                                      (command_sub
                                        left_token: <Left_Backtick '`'>
                                        command_list: 
                                          (command.CommandList
                                            children: [
                                              (command.Pipeline
                                                children: [
                                                  (C {($ VSub_DollarName '$ECHO')} 
                                                    {
                                                      (DQ ($ VSub_DollarName '$compile_var') 
                                                        ($ VSub_DollarName '$compile_command') ($ VSub_DollarName '$compile_rpath')
                                                      )
                                                    }
                                                  )
                                                  (C {($ VSub_DollarName '$SED')} 
                                                    {(SQ <'s%@OUTPUT@%$progdir/$file%g'>)}
                                                  )
                                                ]
                                                negated: F
                                              )
                                            ]
                                          )
                                      )
                                    }
                                )
                              ]
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(Lit_Star '*') (Lit_Comma ',') (no)}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:link_command)
                                  op: Equal
                                  rhs: 
                                    {($ VSub_DollarName '$compile_var') 
                                      ($ VSub_DollarName '$compile_command') ($ VSub_DollarName '$compile_rpath')
                                    }
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:relink_command)
                                  op: Equal
                                  rhs: 
                                    {($ VSub_DollarName '$finalize_var') 
                                      ($ VSub_DollarName '$finalize_command') ($ VSub_DollarName '$finalize_rpath')
                                    }
                                )
                              ]
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(Lit_Star '*') (Lit_Comma ',') (needless)}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:link_command)
                                  op: Equal
                                  rhs: 
                                    {($ VSub_DollarName '$finalize_var') 
                                      ($ VSub_DollarName '$compile_command') ($ VSub_DollarName '$finalize_rpath')
                                    }
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:relink_command)
                                  op: Equal
                                  rhs: (word.Empty)
                                )
                              ]
                            )
                          ]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:link_command)
                          op: Equal
                          rhs: 
                            {
                              (command_sub
                                left_token: <Left_Backtick '`'>
                                command_list: 
                                  (command.CommandList
                                    children: [
                                      (command.Pipeline
                                        children: [
                                          (C {($ VSub_DollarName '$ECHO')} 
                                            {(DQ ($ VSub_DollarName '$link_command'))}
                                          )
                                          (C {($ VSub_DollarName '$SED')} 
                                            {(SQ <'s%@OUTPUT@%'>) 
                                              (DQ ($ VSub_DollarName '$output_objdir') (/) 
                                                ($ VSub_DollarName '$outputname')
                                              ) (SQ <'%g'>)
                                            }
                                          )
                                        ]
                                        negated: F
                                      )
                                    ]
                                  )
                              )
                            }
                        )
                      ]
                    )
                    (command.AndOr
                      ops: [Op_DPipe]
                      children: [
                        (C {($ VSub_DollarName '$opt_dry_run')})
                        (C {($ VSub_DollarName '$RM')} {($ VSub_DollarName '$output')} 
                          {($ VSub_DollarName '$output_objdir') (/) ($ VSub_DollarName '$outputname')} {($ VSub_DollarName '$output_objdir') (/lt-) ($ VSub_DollarName '$outputname')}
                        )
                      ]
                    )
                    (C {(func_show_eval)} {(DQ ($ VSub_DollarName '$link_command'))} {(SQ <'exit $?'>)})
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$postlink_cmds'))})
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [
                            (C {(func_to_tool_file)} 
                              {
                                (DQ ($ VSub_DollarName '$output_objdir') (/) 
                                  ($ VSub_DollarName '$outputname')
                                )
                              }
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:postlink_cmds)
                                  op: Equal
                                  rhs: 
                                    {
                                      (command_sub
                                        left_token: <Left_Backtick '`'>
                                        command_list: 
                                          (command.CommandList
                                            children: [
                                              (command.Pipeline
                                                children: [
                                                  (C {(func_echo_all)} 
                                                    {(DQ ($ VSub_DollarName '$postlink_cmds'))}
                                                  )
                                                  (C {($ VSub_DollarName '$SED')} {(-e)} 
                                                    {(SQ <'s%@OUTPUT@%'>) 
                                                      (DQ ($ VSub_DollarName '$output_objdir') (/) 
                                                        ($ VSub_DollarName '$outputname')
                                                      ) (SQ <'%g'>)
                                                    } {(-e)} {(SQ <'s%@TOOL_OUTPUT@%'>) (DQ ($ VSub_DollarName '$func_to_tool_file_result')) (SQ <'%g'>)}
                                                  )
                                                ]
                                                negated: F
                                              )
                                            ]
                                          )
                                      )
                                    }
                                )
                              ]
                            )
                            (C {(func_execute_cmds)} {(DQ ($ VSub_DollarName '$postlink_cmds'))} 
                              {(SQ <'exit $?'>)}
                            )
                          ]
                        )
                      ]
                    )
                    (C {(func_verbose)} {(DQ ('creating ') ($ VSub_DollarName '$output'))})
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$relink_command'))})
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [
                            (command.ForEach
                              iter_name: var
                              iter_words: [{($ VSub_DollarName '$variables_saved_for_relink')}]
                              do_arg_iter: F
                              body: 
                                (command.DoGroup
                                  children: [
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (command.Sentence
                                              child: 
                                                (C {(eval)} {(test)} {(-z)} 
                                                  {
                                                    (word_part.EscapedLiteral
                                                      token: <Lit_EscapedChar '\\"'>
                                                    ) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) (Lit_LBrace '{') ($ VSub_DollarName '$var') 
                                                    (Lit_Other '+') (KW_Set set) (Lit_RBrace '}') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>)
                                                  }
                                                )
                                              terminator: <Op_Semi ';'>
                                            )
                                          ]
                                          action: [
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:relink_command)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ ('{ test -z ') 
                                                        (word_part.EscapedLiteral
                                                          token: <Lit_EscapedChar '\\"'>
                                                        ) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) ('{') ($ VSub_DollarName '$var') ('+set}') 
                                                        (word_part.EscapedLiteral
                                                          token: <Lit_EscapedChar '\\"'>
                                                        ) (' || ') ($ VSub_DollarName '$lt_unset') (' ') ($ VSub_DollarName '$var') (' || { ') 
                                                        ($ VSub_DollarName '$var') ('=; export ') ($ VSub_DollarName '$var') ('; }; }; ') ($ VSub_DollarName '$relink_command')
                                                      )
                                                    }
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                        (if_arm
                                          cond: [
                                            (command.Sentence
                                              child: 
                                                (C {(eval)} 
                                                  {(Lit_VarLike 'var_value=') 
                                                    (word_part.EscapedLiteral
                                                      token: <Lit_EscapedChar '\\$'>
                                                    ) ($ VSub_DollarName '$var')
                                                  }
                                                )
                                              terminator: <Op_Semi ';'>
                                            )
                                            (command.Sentence
                                              child: 
                                                (C {(test)} {(-z)} 
                                                  {(DQ ($ VSub_DollarName '$var_value'))}
                                                )
                                              terminator: <Op_Semi ';'>
                                            )
                                          ]
                                          action: [
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:relink_command)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ ($ VSub_DollarName '$var') ('=; export ') 
                                                        ($ VSub_DollarName '$var') ('; ') ($ VSub_DollarName '$relink_command')
                                                      )
                                                    }
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                      ]
                                      else_action: [
                                        (C {(func_quote_for_eval)} 
                                          {(DQ ($ VSub_DollarName '$var_value'))}
                                        )
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:relink_command)
                                              op: Equal
                                              rhs: 
                                                {
                                                  (DQ ($ VSub_DollarName '$var') ('=') 
                                                    ($ VSub_DollarName '$func_quote_for_eval_result') ('; export ') ($ VSub_DollarName '$var') ('; ') ($ VSub_DollarName '$relink_command')
                                                  )
                                                }
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                  ]
                                )
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:relink_command)
                                  op: Equal
                                  rhs: 
                                    {
                                      (DQ ('(cd ') 
                                        (command_sub
                                          left_token: <Left_Backtick '`'>
                                          command_list: (command.CommandList children:[(C {(pwd)})])
                                        ) ('; ') ($ VSub_DollarName '$relink_command') (')')
                                      )
                                    }
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:relink_command)
                                  op: Equal
                                  rhs: 
                                    {
                                      (command_sub
                                        left_token: <Left_Backtick '`'>
                                        command_list: 
                                          (command.CommandList
                                            children: [
                                              (command.Pipeline
                                                children: [
                                                  (C {($ VSub_DollarName '$ECHO')} 
                                                    {(DQ ($ VSub_DollarName '$relink_command'))}
                                                  )
                                                  (C {($ VSub_DollarName '$SED')} 
                                                    {(DQ ($ VSub_DollarName '$sed_quote_subst'))}
                                                  )
                                                ]
                                                negated: F
                                              )
                                            ]
                                          )
                                      )
                                    }
                                )
                              ]
                            )
                          ]
                        )
                      ]
                    )
                    (command.AndOr
                      ops: [Op_DPipe]
                      children: [
                        (C {($ VSub_DollarName '$opt_dry_run')})
                        (command.BraceGroup
                          children: [
                            (command.Case
                              to_match: {($ VSub_DollarName '$output')}
                              arms: [
                                (case_arm
                                  pat_list: [{(Lit_Star '*') (.exe)}]
                                  action: [
                                    (C {(func_stripname)} {(SQ )} {(SQ <.exe>)} 
                                      {(DQ ($ VSub_DollarName '$output'))}
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:output)
                                          op: Equal
                                          rhs: {($ VSub_DollarName '$func_stripname_result')}
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.Case
                              to_match: {($ VSub_DollarName '$host')}
                              arms: [
                                (case_arm
                                  pat_list: [{(Lit_Star '*') (cygwin) (Lit_Star '*')}]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:exeext)
                                          op: Equal
                                          rhs: {(.exe)}
                                        )
                                      ]
                                    )
                                    (C {(func_stripname)} {(SQ )} {(SQ <.exe>)} 
                                      {(DQ ($ VSub_DollarName '$outputname'))}
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:outputname)
                                          op: Equal
                                          rhs: {($ VSub_DollarName '$func_stripname_result')}
                                        )
                                      ]
                                    )
                                  ]
                                )
                                (case_arm
                                  pat_list: [{(Lit_Star '*')}]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:exeext)
                                          op: Equal
                                          rhs: (word.Empty)
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.Case
                              to_match: {($ VSub_DollarName '$host')}
                              arms: [
                                (case_arm
                                  pat_list: [
                                    {(Lit_Star '*') (cygwin) (Lit_Star '*')}
                                    {(Lit_Star '*') (mingw) (Lit_Star '*')}
                                  ]
                                  action: [
                                    (C {(func_dirname_and_basename)} 
                                      {(DQ ($ VSub_DollarName '$output'))} {(DQ )} {(DQ (.))}
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:output_name)
                                          op: Equal
                                          rhs: {($ VSub_DollarName '$func_basename_result')}
                                        )
                                      ]
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:output_path)
                                          op: Equal
                                          rhs: {($ VSub_DollarName '$func_dirname_result')}
                                        )
                                      ]
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:cwrappersource)
                                          op: Equal
                                          rhs: 
                                            {($ VSub_DollarName '$output_path') (/) 
                                              ($ VSub_DollarName '$objdir') (/lt-) ($ VSub_DollarName '$output_name') (.c)
                                            }
                                        )
                                      ]
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:cwrapper)
                                          op: Equal
                                          rhs: 
                                            {($ VSub_DollarName '$output_path') (/) 
                                              ($ VSub_DollarName '$output_name') (.exe)
                                            }
                                        )
                                      ]
                                    )
                                    (C {($ VSub_DollarName '$RM')} 
                                      {($ VSub_DollarName '$cwrappersource')} {($ VSub_DollarName '$cwrapper')}
                                    )
                                    (C {(trap)} 
                                      {
                                        (DQ ($ VSub_DollarName '$RM') (' ') 
                                          ($ VSub_DollarName '$cwrappersource') (' ') ($ VSub_DollarName '$cwrapper') ('; exit ') ($ VSub_DollarName '$EXIT_FAILURE')
                                        )
                                      } {(1)} {(2)} {(15)}
                                    )
                                    (command.Simple
                                      words: [{(func_emit_cwrapperexe_src)}]
                                      redirects: [
                                        (redir.Redir
                                          op: <Redir_Great '>'>
                                          fd: 16777215
                                          arg_word: {($ VSub_DollarName '$cwrappersource')}
                                        )
                                      ]
                                    )
                                    (command.AndOr
                                      ops: [Op_DPipe]
                                      children: [
                                        (C {($ VSub_DollarName '$opt_dry_run')})
                                        (command.BraceGroup
                                          children: [
                                            (C {($ VSub_DollarName '$LTCC')} 
                                              {($ VSub_DollarName '$LTCFLAGS')} {(-o)} {($ VSub_DollarName '$cwrapper')} {($ VSub_DollarName '$cwrappersource')}
                                            )
                                            (C {($ VSub_DollarName '$STRIP')} 
                                              {($ VSub_DollarName '$cwrapper')}
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                    (C {(func_ltwrapper_scriptname)} {($ VSub_DollarName '$cwrapper')})
                                    (C {($ VSub_DollarName '$RM')} 
                                      {($ VSub_DollarName '$func_ltwrapper_scriptname_result')}
                                    )
                                    (C {(trap)} 
                                      {
                                        (DQ ($ VSub_DollarName '$RM') (' ') 
                                          ($ VSub_DollarName '$func_ltwrapper_scriptname_result') ('; exit ') ($ VSub_DollarName '$EXIT_FAILURE')
                                        )
                                      } {(1)} {(2)} {(15)}
                                    )
                                    (command.AndOr
                                      ops: [Op_DPipe]
                                      children: [
                                        (C {($ VSub_DollarName '$opt_dry_run')})
                                        (command.BraceGroup
                                          children: [
                                            (command.If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (command.Sentence
                                                      child: 
                                                        (C {(test)} 
                                                          {(DQ (x) ($ VSub_DollarName '$build'))} {(Lit_Equals '=')} {(DQ (x) ($ VSub_DollarName '$host'))}
                                                        )
                                                      terminator: <Op_Semi ';'>
                                                    )
                                                  ]
                                                  action: [
                                                    (command.Simple
                                                      words: [
                                                        {($ VSub_DollarName '$cwrapper')}
                                                        {(--lt-dump-script)}
                                                      ]
                                                      redirects: [
                                                        (redir.Redir
                                                          op: <Redir_Great '>'>
                                                          fd: 16777215
                                                          arg_word: 
                                                            {
                                                              ($ VSub_DollarName 
'$func_ltwrapper_scriptname_result'
                                                              )
                                                            }
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                )
                                              ]
                                              else_action: [
                                                (command.Simple
                                                  words: [{(func_emit_wrapper)} {(no)}]
                                                  redirects: [
                                                    (redir.Redir
                                                      op: <Redir_Great '>'>
                                                      fd: 16777215
                                                      arg_word: 
                                                        {
                                                          ($ VSub_DollarName 
'$func_ltwrapper_scriptname_result'
                                                          )
                                                        }
                                                    )
                                                  ]
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                  ]
                                )
                                (case_arm
                                  pat_list: [{(Lit_Star '*')}]
                                  action: [
                                    (C {($ VSub_DollarName '$RM')} {($ VSub_DollarName '$output')})
                                    (C {(trap)} 
                                      {
                                        (DQ ($ VSub_DollarName '$RM') (' ') 
                                          ($ VSub_DollarName '$output') ('; exit ') ($ VSub_DollarName '$EXIT_FAILURE')
                                        )
                                      } {(1)} {(2)} {(15)}
                                    )
                                    (command.Simple
                                      words: [{(func_emit_wrapper)} {(no)}]
                                      redirects: [
                                        (redir.Redir
                                          op: <Redir_Great '>'>
                                          fd: 16777215
                                          arg_word: {($ VSub_DollarName '$output')}
                                        )
                                      ]
                                    )
                                    (C {(chmod)} {(Lit_Other '+') (x)} {($ VSub_DollarName '$output')})
                                  ]
                                )
                              ]
                            )
                          ]
                        )
                      ]
                    )
                    (command.ControlFlow
                      token: <ControlFlow_Exit exit>
                      arg_word: {($ VSub_DollarName '$EXIT_SUCCESS')}
                    )
                  ]
                )
              ]
            )
            (command.ForEach
              iter_name: oldlib
              iter_words: [{($ VSub_DollarName '$oldlibs')}]
              do_arg_iter: F
              body: 
                (command.DoGroup
                  children: [
                    (command.Case
                      to_match: {($ VSub_DollarName '$build_libtool_libs')}
                      arms: [
                        (case_arm
                          pat_list: [{(convenience)}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:oldobjs)
                                  op: Equal
                                  rhs: 
                                    {
                                      (DQ ($ VSub_DollarName '$libobjs_save') (' ') 
                                        ($ VSub_DollarName '$symfileobj')
                                      )
                                    }
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:addlibs)
                                  op: Equal
                                  rhs: {($ VSub_DollarName '$convenience')}
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:build_libtool_libs)
                                  op: Equal
                                  rhs: {(no)}
                                )
                              ]
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(module)}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:oldobjs)
                                  op: Equal
                                  rhs: {($ VSub_DollarName '$libobjs_save')}
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:addlibs)
                                  op: Equal
                                  rhs: {($ VSub_DollarName '$old_convenience')}
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:build_libtool_libs)
                                  op: Equal
                                  rhs: {(no)}
                                )
                              ]
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(Lit_Star '*')}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:oldobjs)
                                  op: Equal
                                  rhs: 
                                    {
                                      (DQ ($ VSub_DollarName '$old_deplibs') (' ') 
                                        ($ VSub_DollarName '$non_pic_objects')
                                      )
                                    }
                                )
                              ]
                            )
                            (command.AndOr
                              ops: [Op_DAmp Op_DAmp]
                              children: [
                                (C {($ VSub_DollarName '$preload')})
                                (C {(test)} {(-f)} {(DQ ($ VSub_DollarName '$symfileobj'))})
                                (C {(func_append)} {(oldobjs)} 
                                  {(DQ (' ') ($ VSub_DollarName '$symfileobj'))}
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:addlibs)
                                  op: Equal
                                  rhs: {($ VSub_DollarName '$old_convenience')}
                                )
                              ]
                            )
                          ]
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$addlibs'))})
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:gentop)
                                  op: Equal
                                  rhs: 
                                    {($ VSub_DollarName '$output_objdir') (/) 
                                      (${ VSub_Name outputname) (x)
                                    }
                                )
                              ]
                            )
                            (C {(func_append)} {(generated)} {(DQ (' ') ($ VSub_DollarName '$gentop'))})
                            (C {(func_extract_archives)} {($ VSub_DollarName '$gentop')} 
                              {($ VSub_DollarName '$addlibs')}
                            )
                            (C {(func_append)} {(oldobjs)} 
                              {(DQ (' ') ($ VSub_DollarName '$func_extract_archives_result'))}
                            )
                          ]
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: 
                                (command.AndOr
                                  ops: [Op_DAmp]
                                  children: [
                                    (C {(test)} {(-n)} 
                                      {(DQ ($ VSub_DollarName '$old_archive_from_new_cmds'))}
                                    )
                                    (C {(test)} {(yes)} {(Lit_Equals '=')} 
                                      {(DQ ($ VSub_DollarName '$build_libtool_libs'))}
                                    )
                                  ]
                                )
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:cmds)
                                  op: Equal
                                  rhs: {($ VSub_DollarName '$old_archive_from_new_cmds')}
                                )
                              ]
                            )
                          ]
                        )
                      ]
                      else_action: [
                        (command.If
                          arms: [
                            (if_arm
                              cond: [
                                (command.Sentence
                                  child: (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$dlprefiles'))})
                                  terminator: <Op_Semi ';'>
                                )
                              ]
                              action: [
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:gentop)
                                      op: Equal
                                      rhs: 
                                        {($ VSub_DollarName '$output_objdir') (/) 
                                          (${ VSub_Name outputname) (x)
                                        }
                                    )
                                  ]
                                )
                                (C {(func_append)} {(generated)} 
                                  {(DQ (' ') ($ VSub_DollarName '$gentop'))}
                                )
                                (C {(func_extract_archives)} {($ VSub_DollarName '$gentop')} 
                                  {($ VSub_DollarName '$dlprefiles')}
                                )
                                (C {(func_append)} {(oldobjs)} 
                                  {(DQ (' ') ($ VSub_DollarName '$func_extract_archives_result'))}
                                )
                              ]
                            )
                          ]
                        )
                        (command.If
                          arms: [
                            (if_arm
                              cond: [
                                (command.Sentence
                                  child: 
                                    (command.Subshell
                                      command_list: 
                                        (command.CommandList
                                          children: [
                                            (command.Pipeline
                                              children: [
                                                (command.ForEach
                                                  iter_name: obj
                                                  iter_words: [{($ VSub_DollarName '$oldobjs')}]
                                                  do_arg_iter: F
                                                  body: 
                                                    (command.DoGroup
                                                      children: [
                                                        (C {(func_basename)} 
                                                          {(DQ ($ VSub_DollarName '$obj'))}
                                                        )
                                                        (C {($ VSub_DollarName '$ECHO')} 
                                                          {
                                                            (DQ 
                                                              ($ VSub_DollarName 
'$func_basename_result'
                                                              )
                                                            )
                                                          }
                                                        )
                                                      ]
                                                    )
                                                )
                                                (C {(sort)})
                                                (command.Simple
                                                  words: [{(sort)} {(-uc)}]
                                                  redirects: [
                                                    (redir.Redir
                                                      op: <Redir_Great '>'>
                                                      fd: 16777215
                                                      arg_word: {(/dev/null)}
                                                    )
                                                    (redir.Redir
                                                      op: <Redir_GreatAnd '2>&'>
                                                      fd: 2
                                                      arg_word: {(1)}
                                                    )
                                                  ]
                                                )
                                              ]
                                              negated: F
                                            )
                                          ]
                                        )
                                    )
                                  terminator: <Op_Semi ';'>
                                )
                              ]
                              action: [(C {(Lit_Other ':')})]
                            )
                          ]
                          else_action: [
                            (C {(echo)} 
                              {(DQ ('copying selected object files to avoid basename conflicts...'))}
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:gentop)
                                  op: Equal
                                  rhs: 
                                    {($ VSub_DollarName '$output_objdir') (/) 
                                      (${ VSub_Name outputname) (x)
                                    }
                                )
                              ]
                            )
                            (C {(func_append)} {(generated)} {(DQ (' ') ($ VSub_DollarName '$gentop'))})
                            (C {(func_mkdir_p)} {(DQ ($ VSub_DollarName '$gentop'))})
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:save_oldobjs)
                                  op: Equal
                                  rhs: {($ VSub_DollarName '$oldobjs')}
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:oldobjs) op:Equal rhs:(word.Empty))]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:counter)
                                  op: Equal
                                  rhs: {(1)}
                                )
                              ]
                            )
                            (command.ForEach
                              iter_name: obj
                              iter_words: [{($ VSub_DollarName '$save_oldobjs')}]
                              do_arg_iter: F
                              body: 
                                (command.DoGroup
                                  children: [
                                    (C {(func_basename)} {(DQ ($ VSub_DollarName '$obj'))})
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:objbase)
                                          op: Equal
                                          rhs: {($ VSub_DollarName '$func_basename_result')}
                                        )
                                      ]
                                    )
                                    (command.Case
                                      to_match: {(DQ (' ') ($ VSub_DollarName '$oldobjs') (' '))}
                                      arms: [
                                        (case_arm
                                          pat_list: [{(DQ (' '))}]
                                          action: [
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:oldobjs)
                                                  op: Equal
                                                  rhs: {($ VSub_DollarName '$obj')}
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                        (case_arm
                                          pat_list: [
                                            {(Lit_Star '*') (Lit_LBracket '[') 
                                              (word_part.EscapedLiteral
                                                token: <Lit_EscapedChar '\\ '>
                                              ) (/) (Lit_RBracket ']') (DQ ($ VSub_DollarName '$objbase') (' ')) (Lit_Star '*')
                                            }
                                          ]
                                          action: [
                                            (command.WhileUntil
                                              keyword: <KW_While while>
                                              cond: [
                                                (command.Sentence
                                                  child: (C {(Lit_Other ':')})
                                                  terminator: <Op_Semi ';'>
                                                )
                                              ]
                                              body: 
                                                (command.DoGroup
                                                  children: [
                                                    (command.ShAssignment
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (sh_lhs_expr.Name name:newobj)
                                                          op: Equal
                                                          rhs: 
                                                            {(lt) ($ VSub_DollarName '$counter') (-) 
                                                              ($ VSub_DollarName '$objbase')
                                                            }
                                                        )
                                                      ]
                                                    )
                                                    (C {(func_arith)} {($ VSub_DollarName '$counter')} 
                                                      {(Lit_Other '+')} {(1)}
                                                    )
                                                    (command.ShAssignment
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (sh_lhs_expr.Name name:counter)
                                                          op: Equal
                                                          rhs: 
                                                            {
                                                              ($ VSub_DollarName '$func_arith_result')
                                                            }
                                                        )
                                                      ]
                                                    )
                                                    (command.Case
                                                      to_match: 
                                                        {
                                                          (DQ (' ') ($ VSub_DollarName '$oldobjs') 
                                                            (' ')
                                                          )
                                                        }
                                                      arms: [
                                                        (case_arm
                                                          pat_list: [
                                                            {(Lit_Star '*') (Lit_LBracket '[') 
                                                              (word_part.EscapedLiteral
                                                                token: <Lit_EscapedChar '\\ '>
                                                              ) (/) (Lit_RBracket ']') (DQ ($ VSub_DollarName '$newobj') (' ')) (Lit_Star '*')
                                                            }
                                                          ]
                                                        )
                                                        (case_arm
                                                          pat_list: [{(Lit_Star '*')}]
                                                          action: [
                                                            (command.If
                                                              arms: [
                                                                (if_arm
                                                                  cond: [
                                                                    (command.Sentence
                                                                      child: 
                                                                        (C {(test)} {(KW_Bang '!')} 
                                                                          {(-f)} {(DQ ($ VSub_DollarName '$gentop') (/) ($ VSub_DollarName '$newobj'))}
                                                                        )
                                                                      terminator: <Op_Semi ';'>
                                                                    )
                                                                  ]
                                                                  action: [
                                                                    (command.Sentence
                                                                      child: 
                                                                        (command.ControlFlow
                                                                          token: 
                                                                            <ControlFlow_Break break>
                                                                        )
                                                                      terminator: <Op_Semi ';'>
                                                                    )
                                                                  ]
                                                                )
                                                              ]
                                                            )
                                                          ]
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                )
                                            )
                                            (C {(func_show_eval)} 
                                              {
                                                (DQ ('ln ') ($ VSub_DollarName '$obj') (' ') 
                                                  ($ VSub_DollarName '$gentop') (/) ($ VSub_DollarName '$newobj') (' || cp ') ($ VSub_DollarName '$obj') (' ') 
                                                  ($ VSub_DollarName '$gentop') (/) ($ VSub_DollarName '$newobj')
                                                )
                                              }
                                            )
                                            (C {(func_append)} {(oldobjs)} 
                                              {
                                                (DQ (' ') ($ VSub_DollarName '$gentop') (/) 
                                                  ($ VSub_DollarName '$newobj')
                                                )
                                              }
                                            )
                                          ]
                                        )
                                        (case_arm
                                          pat_list: [{(Lit_Star '*')}]
                                          action: [
                                            (C {(func_append)} {(oldobjs)} 
                                              {(DQ (' ') ($ VSub_DollarName '$obj'))}
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                  ]
                                )
                            )
                          ]
                        )
                        (C {(func_to_tool_file)} {(DQ ($ VSub_DollarName '$oldlib'))} 
                          {(func_convert_file_msys_to_w32)}
                        )
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:tool_oldlib)
                              op: Equal
                              rhs: {($ VSub_DollarName '$func_to_tool_file_result')}
                            )
                          ]
                        )
                        (C {(eval)} 
                          {(Lit_VarLike 'cmds=') 
                            (word_part.EscapedLiteral
                              token: <Lit_EscapedChar '\\"'>
                            ) ($ VSub_DollarName '$old_archive_cmds') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>)
                          }
                        )
                        (C {(func_len)} {(DQ (' ') ($ VSub_DollarName '$cmds'))})
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:len)
                              op: Equal
                              rhs: {($ VSub_DollarName '$func_len_result')}
                            )
                          ]
                        )
                        (command.If
                          arms: [
                            (if_arm
                              cond: [
                                (command.Sentence
                                  child: 
                                    (command.AndOr
                                      ops: [Op_DPipe]
                                      children: [
                                        (C {(test)} {(DQ ($ VSub_DollarName '$len'))} {(-lt)} 
                                          {(DQ ($ VSub_DollarName '$max_cmd_len'))}
                                        )
                                        (C {(test)} {(DQ ($ VSub_DollarName '$max_cmd_len'))} {(-le)} 
                                          {(-1)}
                                        )
                                      ]
                                    )
                                  terminator: <Op_Semi ';'>
                                )
                              ]
                              action: [
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:cmds)
                                      op: Equal
                                      rhs: {($ VSub_DollarName '$old_archive_cmds')}
                                    )
                                  ]
                                )
                              ]
                            )
                            (if_arm
                              cond: [
                                (command.Sentence
                                  child: 
                                    (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$archiver_list_spec'))})
                                  terminator: <Op_Semi ';'>
                                )
                              ]
                              action: [
                                (C {(func_verbose)} {(DQ ('using command file archive linking...'))})
                                (command.ForEach
                                  iter_name: obj
                                  iter_words: [{($ VSub_DollarName '$oldobjs')}]
                                  do_arg_iter: F
                                  body: 
                                    (command.DoGroup
                                      children: [
                                        (C {(func_to_tool_file)} {(DQ ($ VSub_DollarName '$obj'))})
                                        (C {($ VSub_DollarName '$ECHO')} 
                                          {(DQ ($ VSub_DollarName '$func_to_tool_file_result'))}
                                        )
                                      ]
                                    )
                                  redirects: [
                                    (redir.Redir
                                      op: <Redir_Great '>'>
                                      fd: 16777215
                                      arg_word: 
                                        {($ VSub_DollarName '$output_objdir') (/) 
                                          ($ VSub_DollarName '$libname') (.libcmd)
                                        }
                                    )
                                  ]
                                )
                                (C {(func_to_tool_file)} 
                                  {
                                    (DQ ($ VSub_DollarName '$output_objdir') (/) 
                                      ($ VSub_DollarName '$libname') (.libcmd)
                                    )
                                  }
                                )
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:oldobjs)
                                      op: Equal
                                      rhs: 
                                        {
                                          (DQ (' ') ($ VSub_DollarName '$archiver_list_spec') 
                                            ($ VSub_DollarName '$func_to_tool_file_result')
                                          )
                                        }
                                    )
                                  ]
                                )
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:cmds)
                                      op: Equal
                                      rhs: {($ VSub_DollarName '$old_archive_cmds')}
                                    )
                                  ]
                                )
                              ]
                            )
                          ]
                          else_action: [
                            (C {(func_verbose)} {(DQ ('using piecewise archive linking...'))})
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:save_RANLIB)
                                  op: Equal
                                  rhs: {($ VSub_DollarName '$RANLIB')}
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:RANLIB)
                                  op: Equal
                                  rhs: {(Lit_Other ':')}
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:objlist) op:Equal rhs:(word.Empty))]
                            )
                            (command.ShAssignment
                              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:concat_cmds) op:Equal rhs:(word.Empty))]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:save_oldobjs)
                                  op: Equal
                                  rhs: {($ VSub_DollarName '$oldobjs')}
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:oldobjs) op:Equal rhs:(word.Empty))]
                            )
                            (command.ForEach
                              iter_name: obj
                              iter_words: [{($ VSub_DollarName '$save_oldobjs')}]
                              do_arg_iter: F
                              body: 
                                (command.DoGroup
                                  children: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:last_oldobj)
                                          op: Equal
                                          rhs: {($ VSub_DollarName '$obj')}
                                        )
                                      ]
                                    )
                                  ]
                                )
                            )
                            (C {(eval)} 
                              {(Lit_VarLike 'test_cmds=') 
                                (word_part.EscapedLiteral
                                  token: <Lit_EscapedChar '\\"'>
                                ) ($ VSub_DollarName '$old_archive_cmds') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>)
                              }
                            )
                            (C {(func_len)} {(DQ (' ') ($ VSub_DollarName '$test_cmds'))})
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:len0)
                                  op: Equal
                                  rhs: {($ VSub_DollarName '$func_len_result')}
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:len)
                                  op: Equal
                                  rhs: {($ VSub_DollarName '$len0')}
                                )
                              ]
                            )
                            (command.ForEach
                              iter_name: obj
                              iter_words: [{($ VSub_DollarName '$save_oldobjs')}]
                              do_arg_iter: F
                              body: 
                                (command.DoGroup
                                  children: [
                                    (C {(func_len)} {(DQ (' ') ($ VSub_DollarName '$obj'))})
                                    (C {(func_arith)} {($ VSub_DollarName '$len')} {(Lit_Other '+')} 
                                      {($ VSub_DollarName '$func_len_result')}
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:len)
                                          op: Equal
                                          rhs: {($ VSub_DollarName '$func_arith_result')}
                                        )
                                      ]
                                    )
                                    (C {(func_append)} {(objlist)} 
                                      {(DQ (' ') ($ VSub_DollarName '$obj'))}
                                    )
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (command.Sentence
                                              child: 
                                                (C {(test)} {(DQ ($ VSub_DollarName '$len'))} {(-lt)} 
                                                  {(DQ ($ VSub_DollarName '$max_cmd_len'))}
                                                )
                                              terminator: <Op_Semi ';'>
                                            )
                                          ]
                                          action: [(C {(Lit_Other ':')})]
                                        )
                                      ]
                                      else_action: [
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:oldobjs)
                                              op: Equal
                                              rhs: {($ VSub_DollarName '$objlist')}
                                            )
                                          ]
                                        )
                                        (command.If
                                          arms: [
                                            (if_arm
                                              cond: [
                                                (command.Sentence
                                                  child: 
                                                    (C {(test)} {(DQ ($ VSub_DollarName '$obj'))} 
                                                      {(Lit_Equals '=')} {(DQ ($ VSub_DollarName '$last_oldobj'))}
                                                    )
                                                  terminator: <Op_Semi ';'>
                                                )
                                              ]
                                              action: [
                                                (command.ShAssignment
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (sh_lhs_expr.Name name:RANLIB)
                                                      op: Equal
                                                      rhs: {($ VSub_DollarName '$save_RANLIB')}
                                                    )
                                                  ]
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                        (command.AndOr
                                          ops: [Op_DPipe]
                                          children: [
                                            (C {(test)} {(-z)} {(DQ ($ VSub_DollarName '$concat_cmds'))})
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:concat_cmds)
                                                  op: Equal
                                                  rhs: 
                                                    {($ VSub_DollarName '$concat_cmds') 
                                                      (Lit_TildeLike '~')
                                                    }
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                        (C {(eval)} 
                                          {(Lit_VarLike 'concat_cmds=') 
                                            (word_part.EscapedLiteral
                                              token: <Lit_EscapedChar '\\"'>
                                            ) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) (concat_cmds) 
                                            ($ VSub_DollarName '$old_archive_cmds') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>)
                                          }
                                        )
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:objlist)
                                              op: Equal
                                              rhs: (word.Empty)
                                            )
                                          ]
                                        )
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:len)
                                              op: Equal
                                              rhs: {($ VSub_DollarName '$len0')}
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                  ]
                                )
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:RANLIB)
                                  op: Equal
                                  rhs: {($ VSub_DollarName '$save_RANLIB')}
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:oldobjs)
                                  op: Equal
                                  rhs: {($ VSub_DollarName '$objlist')}
                                )
                              ]
                            )
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: (C {(test)} {(-z)} {(DQ ($ VSub_DollarName '$oldobjs'))})
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (C {(eval)} 
                                      {(Lit_VarLike 'cmds=') 
                                        (word_part.EscapedLiteral
                                          token: <Lit_EscapedChar '\\"'>
                                        ) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) (concat_cmds) 
                                        (word_part.EscapedLiteral
                                          token: <Lit_EscapedChar '\\"'>
                                        )
                                      }
                                    )
                                  ]
                                )
                              ]
                              else_action: [
                                (C {(eval)} 
                                  {(Lit_VarLike 'cmds=') 
                                    (word_part.EscapedLiteral
                                      token: <Lit_EscapedChar '\\"'>
                                    ) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) (concat_cmds) (Lit_TildeLike '~') 
                                    (word_part.EscapedLiteral
                                      token: <Lit_EscapedChar '\\$'>
                                    ) (old_archive_cmds) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>)
                                  }
                                )
                              ]
                            )
                          ]
                        )
                      ]
                    )
                    (C {(func_execute_cmds)} {(DQ ($ VSub_DollarName '$cmds'))} {(SQ <'exit $?'>)})
                  ]
                )
            )
            (command.AndOr
              ops: [Op_DAmp]
              children: [
                (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$generated'))})
                (C {(func_show_eval)} {(DQ (${ VSub_Name RM) (r) ($ VSub_DollarName '$generated'))})
              ]
            )
            (command.Case
              to_match: {($ VSub_DollarName '$output')}
              arms: [
                (case_arm
                  pat_list: [{(Lit_Star '*') (.la)}]
                  action: [
                    (command.ShAssignment
                      pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:old_library) op:Equal rhs:(word.Empty))]
                    )
                    (command.AndOr
                      ops: [Op_DAmp]
                      children: [
                        (C {(test)} {(yes)} {(Lit_Equals '=')} 
                          {(DQ ($ VSub_DollarName '$build_old_libs'))}
                        )
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:old_library)
                              op: Equal
                              rhs: {($ VSub_DollarName '$libname') (.) ($ VSub_DollarName '$libext')}
                            )
                          ]
                        )
                      ]
                    )
                    (C {(func_verbose)} {(DQ ('creating ') ($ VSub_DollarName '$output'))})
                    (command.ForEach
                      iter_name: var
                      iter_words: [{($ VSub_DollarName '$variables_saved_for_relink')}]
                      do_arg_iter: F
                      body: 
                        (command.DoGroup
                          children: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (C {(eval)} {(test)} {(-z)} 
                                          {(word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) 
                                            (word_part.EscapedLiteral
                                              token: <Lit_EscapedChar '\\$'>
                                            ) (Lit_LBrace '{') ($ VSub_DollarName '$var') (Lit_Other '+') (KW_Set set) (Lit_RBrace '}') 
                                            (word_part.EscapedLiteral
                                              token: <Lit_EscapedChar '\\"'>
                                            )
                                          }
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:relink_command)
                                          op: Equal
                                          rhs: 
                                            {
                                              (DQ ('{ test -z ') 
                                                (word_part.EscapedLiteral
                                                  token: <Lit_EscapedChar '\\"'>
                                                ) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) ('{') ($ VSub_DollarName '$var') ('+set}') 
                                                (word_part.EscapedLiteral
                                                  token: <Lit_EscapedChar '\\"'>
                                                ) (' || ') ($ VSub_DollarName '$lt_unset') (' ') ($ VSub_DollarName '$var') (' || { ') 
                                                ($ VSub_DollarName '$var') ('=; export ') ($ VSub_DollarName '$var') ('; }; }; ') ($ VSub_DollarName '$relink_command')
                                              )
                                            }
                                        )
                                      ]
                                    )
                                  ]
                                )
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (C {(eval)} 
                                          {(Lit_VarLike 'var_value=') 
                                            (word_part.EscapedLiteral
                                              token: <Lit_EscapedChar '\\$'>
                                            ) ($ VSub_DollarName '$var')
                                          }
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                    (command.Sentence
                                      child: (C {(test)} {(-z)} {(DQ ($ VSub_DollarName '$var_value'))})
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:relink_command)
                                          op: Equal
                                          rhs: 
                                            {
                                              (DQ ($ VSub_DollarName '$var') ('=; export ') 
                                                ($ VSub_DollarName '$var') ('; ') ($ VSub_DollarName '$relink_command')
                                              )
                                            }
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                              else_action: [
                                (C {(func_quote_for_eval)} {(DQ ($ VSub_DollarName '$var_value'))})
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:relink_command)
                                      op: Equal
                                      rhs: 
                                        {
                                          (DQ ($ VSub_DollarName '$var') ('=') 
                                            ($ VSub_DollarName '$func_quote_for_eval_result') ('; export ') ($ VSub_DollarName '$var') ('; ') ($ VSub_DollarName '$relink_command')
                                          )
                                        }
                                    )
                                  ]
                                )
                              ]
                            )
                          ]
                        )
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:relink_command)
                          op: Equal
                          rhs: 
                            {
                              (DQ ('(cd ') 
                                (command_sub
                                  left_token: <Left_Backtick '`'>
                                  command_list: (command.CommandList children:[(C {(pwd)})])
                                ) ('; ') ($ VSub_DollarName '$SHELL') (' ') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) 
                                ($ VSub_DollarName '$progpath') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) (' ') ($ VSub_DollarName '$preserve_args') 
                                (' --mode=relink ') ($ VSub_DollarName '$libtool_args') (' @inst_prefix_dir@)')
                              )
                            }
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:relink_command)
                          op: Equal
                          rhs: 
                            {
                              (command_sub
                                left_token: <Left_Backtick '`'>
                                command_list: 
                                  (command.CommandList
                                    children: [
                                      (command.Pipeline
                                        children: [
                                          (C {($ VSub_DollarName '$ECHO')} 
                                            {(DQ ($ VSub_DollarName '$relink_command'))}
                                          )
                                          (C {($ VSub_DollarName '$SED')} 
                                            {(DQ ($ VSub_DollarName '$sed_quote_subst'))}
                                          )
                                        ]
                                        negated: F
                                      )
                                    ]
                                  )
                              )
                            }
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: 
                                (C {(test)} {(yes)} {(Lit_Equals '=')} 
                                  {(DQ ($ VSub_DollarName '$hardcode_automatic'))}
                                )
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:relink_command)
                                  op: Equal
                                  rhs: (word.Empty)
                                )
                              ]
                            )
                          ]
                        )
                      ]
                    )
                    (command.AndOr
                      ops: [Op_DPipe]
                      children: [
                        (C {($ VSub_DollarName '$opt_dry_run')})
                        (command.BraceGroup
                          children: [
                            (command.ForEach
                              iter_name: installed
                              iter_words: [{(no)} {(yes)}]
                              do_arg_iter: F
                              body: 
                                (command.DoGroup
                                  children: [
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (command.Sentence
                                              child: 
                                                (C {(test)} {(yes)} {(Lit_Equals '=')} 
                                                  {(DQ ($ VSub_DollarName '$installed'))}
                                                )
                                              terminator: <Op_Semi ';'>
                                            )
                                          ]
                                          action: [
                                            (command.If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (command.Sentence
                                                      child: 
                                                        (C {(test)} {(-z)} 
                                                          {(DQ ($ VSub_DollarName '$install_libdir'))}
                                                        )
                                                      terminator: <Op_Semi ';'>
                                                    )
                                                  ]
                                                  action: [
                                                    (command.ControlFlow
                                                      token: <ControlFlow_Break break>
                                                    )
                                                  ]
                                                )
                                              ]
                                            )
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:output)
                                                  op: Equal
                                                  rhs: 
                                                    {($ VSub_DollarName '$output_objdir') (/) 
                                                      (${ VSub_Name outputname) (i)
                                                    }
                                                )
                                              ]
                                            )
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:newdependency_libs)
                                                  op: Equal
                                                  rhs: (word.Empty)
                                                )
                                              ]
                                            )
                                            (command.ForEach
                                              iter_name: deplib
                                              iter_words: [{($ VSub_DollarName '$dependency_libs')}]
                                              do_arg_iter: F
                                              body: 
                                                (command.DoGroup
                                                  children: [
                                                    (command.Case
                                                      to_match: {($ VSub_DollarName '$deplib')}
                                                      arms: [
                                                        (case_arm
                                                          pat_list: [{(Lit_Star '*') (.la)}]
                                                          action: [
                                                            (C {(func_basename)} 
                                                              {(DQ ($ VSub_DollarName '$deplib'))}
                                                            )
                                                            (command.ShAssignment
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: (sh_lhs_expr.Name name:name)
                                                                  op: Equal
                                                                  rhs: 
                                                                    {
                                                                      ($ VSub_DollarName 
'$func_basename_result'
                                                                      )
                                                                    }
                                                                )
                                                              ]
                                                            )
                                                            (C {(func_resolve_sysroot)} 
                                                              {(DQ ($ VSub_DollarName '$deplib'))}
                                                            )
                                                            (C {(eval)} 
                                                              {(Lit_VarLike 'libdir=') 
                                                                (command_sub
                                                                  left_token: <Left_Backtick '`'>
                                                                  command_list: 
                                                                    (command.CommandList
                                                                      children: [
                                                                        (C 
                                                                          {
                                                                            ($ VSub_DollarName '$SED')
                                                                          } {(-n)} {(-e)} {(SQ <'s/^libdir=\\(.*\\)$/\\1/p'>)} {($ VSub_DollarName '$func_resolve_sysroot_result')}
                                                                        )
                                                                      ]
                                                                    )
                                                                )
                                                              }
                                                            )
                                                            (command.AndOr
                                                              ops: [Op_DAmp]
                                                              children: [
                                                                (C {(test)} {(-z)} 
                                                                  {(DQ ($ VSub_DollarName '$libdir'))}
                                                                )
                                                                (C {(func_fatal_error)} 
                                                                  {
                                                                    (DQ ("'") 
                                                                      ($ VSub_DollarName '$deplib') ("' is not a valid libtool archive")
                                                                    )
                                                                  }
                                                                )
                                                              ]
                                                            )
                                                            (C {(func_append)} {(newdependency_libs)} 
                                                              {
                                                                (DQ (' ') 
                                                                  (braced_var_sub
                                                                    token: <VSub_Name lt_sysroot>
                                                                    suffix_op: 
                                                                      (suffix_op.Unary
                                                                        op_id: VTest_ColonPlus
                                                                        arg_word: {('=')}
                                                                      )
                                                                  ) ($ VSub_DollarName '$libdir') (/) ($ VSub_DollarName '$name')
                                                                )
                                                              }
                                                            )
                                                          ]
                                                        )
                                                        (case_arm
                                                          pat_list: [{(-L) (Lit_Star '*')}]
                                                          action: [
                                                            (C {(func_stripname)} {(-L)} {(SQ )} 
                                                              {(DQ ($ VSub_DollarName '$deplib'))}
                                                            )
                                                            (C {(func_replace_sysroot)} 
                                                              {
                                                                (DQ 
                                                                  ($ VSub_DollarName 
'$func_stripname_result'
                                                                  )
                                                                )
                                                              }
                                                            )
                                                            (C {(func_append)} {(newdependency_libs)} 
                                                              {
                                                                (DQ (' -L') 
                                                                  ($ VSub_DollarName 
'$func_replace_sysroot_result'
                                                                  )
                                                                )
                                                              }
                                                            )
                                                          ]
                                                        )
                                                        (case_arm
                                                          pat_list: [{(-R) (Lit_Star '*')}]
                                                          action: [
                                                            (C {(func_stripname)} {(-R)} {(SQ )} 
                                                              {(DQ ($ VSub_DollarName '$deplib'))}
                                                            )
                                                            (C {(func_replace_sysroot)} 
                                                              {
                                                                (DQ 
                                                                  ($ VSub_DollarName 
'$func_stripname_result'
                                                                  )
                                                                )
                                                              }
                                                            )
                                                            (C {(func_append)} {(newdependency_libs)} 
                                                              {
                                                                (DQ (' -R') 
                                                                  ($ VSub_DollarName 
'$func_replace_sysroot_result'
                                                                  )
                                                                )
                                                              }
                                                            )
                                                          ]
                                                        )
                                                        (case_arm
                                                          pat_list: [{(Lit_Star '*')}]
                                                          action: [
                                                            (C {(func_append)} {(newdependency_libs)} 
                                                              {
                                                                (DQ (' ') 
                                                                  ($ VSub_DollarName '$deplib')
                                                                )
                                                              }
                                                            )
                                                          ]
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                )
                                            )
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:dependency_libs)
                                                  op: Equal
                                                  rhs: {($ VSub_DollarName '$newdependency_libs')}
                                                )
                                              ]
                                            )
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:newdlfiles)
                                                  op: Equal
                                                  rhs: (word.Empty)
                                                )
                                              ]
                                            )
                                            (command.ForEach
                                              iter_name: lib
                                              iter_words: [{($ VSub_DollarName '$dlfiles')}]
                                              do_arg_iter: F
                                              body: 
                                                (command.DoGroup
                                                  children: [
                                                    (command.Case
                                                      to_match: {($ VSub_DollarName '$lib')}
                                                      arms: [
                                                        (case_arm
                                                          pat_list: [{(Lit_Star '*') (.la)}]
                                                          action: [
                                                            (C {(func_basename)} 
                                                              {(DQ ($ VSub_DollarName '$lib'))}
                                                            )
                                                            (command.ShAssignment
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: (sh_lhs_expr.Name name:name)
                                                                  op: Equal
                                                                  rhs: 
                                                                    {
                                                                      ($ VSub_DollarName 
'$func_basename_result'
                                                                      )
                                                                    }
                                                                )
                                                              ]
                                                            )
                                                            (C {(eval)} 
                                                              {(Lit_VarLike 'libdir=') 
                                                                (command_sub
                                                                  left_token: <Left_Backtick '`'>
                                                                  command_list: 
                                                                    (command.CommandList
                                                                      children: [
                                                                        (C 
                                                                          {
                                                                            ($ VSub_DollarName '$SED')
                                                                          } {(-n)} {(-e)} {(SQ <'s/^libdir=\\(.*\\)$/\\1/p'>)} {($ VSub_DollarName '$lib')}
                                                                        )
                                                                      ]
                                                                    )
                                                                )
                                                              }
                                                            )
                                                            (command.AndOr
                                                              ops: [Op_DAmp]
                                                              children: [
                                                                (C {(test)} {(-z)} 
                                                                  {(DQ ($ VSub_DollarName '$libdir'))}
                                                                )
                                                                (C {(func_fatal_error)} 
                                                                  {
                                                                    (DQ ("'") 
                                                                      ($ VSub_DollarName '$lib') ("' is not a valid libtool archive")
                                                                    )
                                                                  }
                                                                )
                                                              ]
                                                            )
                                                            (C {(func_append)} {(newdlfiles)} 
                                                              {
                                                                (DQ (' ') 
                                                                  (braced_var_sub
                                                                    token: <VSub_Name lt_sysroot>
                                                                    suffix_op: 
                                                                      (suffix_op.Unary
                                                                        op_id: VTest_ColonPlus
                                                                        arg_word: {('=')}
                                                                      )
                                                                  ) ($ VSub_DollarName '$libdir') (/) ($ VSub_DollarName '$name')
                                                                )
                                                              }
                                                            )
                                                          ]
                                                        )
                                                        (case_arm
                                                          pat_list: [{(Lit_Star '*')}]
                                                          action: [
                                                            (C {(func_append)} {(newdlfiles)} 
                                                              {(DQ (' ') ($ VSub_DollarName '$lib'))}
                                                            )
                                                          ]
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                )
                                            )
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:dlfiles)
                                                  op: Equal
                                                  rhs: {($ VSub_DollarName '$newdlfiles')}
                                                )
                                              ]
                                            )
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:newdlprefiles)
                                                  op: Equal
                                                  rhs: (word.Empty)
                                                )
                                              ]
                                            )
                                            (command.ForEach
                                              iter_name: lib
                                              iter_words: [{($ VSub_DollarName '$dlprefiles')}]
                                              do_arg_iter: F
                                              body: 
                                                (command.DoGroup
                                                  children: [
                                                    (command.Case
                                                      to_match: {($ VSub_DollarName '$lib')}
                                                      arms: [
                                                        (case_arm
                                                          pat_list: [{(Lit_Star '*') (.la)}]
                                                          action: [
                                                            (C {(func_basename)} 
                                                              {(DQ ($ VSub_DollarName '$lib'))}
                                                            )
                                                            (command.ShAssignment
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: (sh_lhs_expr.Name name:name)
                                                                  op: Equal
                                                                  rhs: 
                                                                    {
                                                                      ($ VSub_DollarName 
'$func_basename_result'
                                                                      )
                                                                    }
                                                                )
                                                              ]
                                                            )
                                                            (C {(eval)} 
                                                              {(Lit_VarLike 'libdir=') 
                                                                (command_sub
                                                                  left_token: <Left_Backtick '`'>
                                                                  command_list: 
                                                                    (command.CommandList
                                                                      children: [
                                                                        (C 
                                                                          {
                                                                            ($ VSub_DollarName '$SED')
                                                                          } {(-n)} {(-e)} {(SQ <'s/^libdir=\\(.*\\)$/\\1/p'>)} {($ VSub_DollarName '$lib')}
                                                                        )
                                                                      ]
                                                                    )
                                                                )
                                                              }
                                                            )
                                                            (command.AndOr
                                                              ops: [Op_DAmp]
                                                              children: [
                                                                (C {(test)} {(-z)} 
                                                                  {(DQ ($ VSub_DollarName '$libdir'))}
                                                                )
                                                                (C {(func_fatal_error)} 
                                                                  {
                                                                    (DQ ("'") 
                                                                      ($ VSub_DollarName '$lib') ("' is not a valid libtool archive")
                                                                    )
                                                                  }
                                                                )
                                                              ]
                                                            )
                                                            (C {(func_append)} {(newdlprefiles)} 
                                                              {
                                                                (DQ (' ') 
                                                                  (braced_var_sub
                                                                    token: <VSub_Name lt_sysroot>
                                                                    suffix_op: 
                                                                      (suffix_op.Unary
                                                                        op_id: VTest_ColonPlus
                                                                        arg_word: {('=')}
                                                                      )
                                                                  ) ($ VSub_DollarName '$libdir') (/) ($ VSub_DollarName '$name')
                                                                )
                                                              }
                                                            )
                                                          ]
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                )
                                            )
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:dlprefiles)
                                                  op: Equal
                                                  rhs: {($ VSub_DollarName '$newdlprefiles')}
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                      ]
                                      else_action: [
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:newdlfiles)
                                              op: Equal
                                              rhs: (word.Empty)
                                            )
                                          ]
                                        )
                                        (command.ForEach
                                          iter_name: lib
                                          iter_words: [{($ VSub_DollarName '$dlfiles')}]
                                          do_arg_iter: F
                                          body: 
                                            (command.DoGroup
                                              children: [
                                                (command.Case
                                                  to_match: {($ VSub_DollarName '$lib')}
                                                  arms: [
                                                    (case_arm
                                                      pat_list: [
                                                        {(Lit_LBracket '[') 
                                                          (word_part.EscapedLiteral
                                                            token: <Lit_EscapedChar '\\\\'>
                                                          ) (/) (Lit_RBracket ']') (Lit_Star '*')
                                                        }
                                                        {(Lit_LBracket '[') (A-Za-z) 
                                                          (Lit_RBracket ']') (Lit_Other ':') (Lit_LBracket '[') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\\\'>) (/) 
                                                          (Lit_RBracket ']') (Lit_Star '*')
                                                        }
                                                      ]
                                                      action: [
                                                        (command.ShAssignment
                                                          pairs: [
                                                            (assign_pair
                                                              lhs: (sh_lhs_expr.Name name:abs)
                                                              op: Equal
                                                              rhs: {($ VSub_DollarName '$lib')}
                                                            )
                                                          ]
                                                        )
                                                      ]
                                                    )
                                                    (case_arm
                                                      pat_list: [{(Lit_Star '*')}]
                                                      action: [
                                                        (command.ShAssignment
                                                          pairs: [
                                                            (assign_pair
                                                              lhs: (sh_lhs_expr.Name name:abs)
                                                              op: Equal
                                                              rhs: 
                                                                {
                                                                  (command_sub
                                                                    left_token: <Left_Backtick '`'>
                                                                    command_list: 
                                                                      (command.CommandList
                                                                        children: [(C {(pwd)})]
                                                                      )
                                                                  ) (DQ (/) ($ VSub_DollarName '$lib'))
                                                                }
                                                            )
                                                          ]
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                )
                                                (C {(func_append)} {(newdlfiles)} 
                                                  {(DQ (' ') ($ VSub_DollarName '$abs'))}
                                                )
                                              ]
                                            )
                                        )
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:dlfiles)
                                              op: Equal
                                              rhs: {($ VSub_DollarName '$newdlfiles')}
                                            )
                                          ]
                                        )
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:newdlprefiles)
                                              op: Equal
                                              rhs: (word.Empty)
                                            )
                                          ]
                                        )
                                        (command.ForEach
                                          iter_name: lib
                                          iter_words: [{($ VSub_DollarName '$dlprefiles')}]
                                          do_arg_iter: F
                                          body: 
                                            (command.DoGroup
                                              children: [
                                                (command.Case
                                                  to_match: {($ VSub_DollarName '$lib')}
                                                  arms: [
                                                    (case_arm
                                                      pat_list: [
                                                        {(Lit_LBracket '[') 
                                                          (word_part.EscapedLiteral
                                                            token: <Lit_EscapedChar '\\\\'>
                                                          ) (/) (Lit_RBracket ']') (Lit_Star '*')
                                                        }
                                                        {(Lit_LBracket '[') (A-Za-z) 
                                                          (Lit_RBracket ']') (Lit_Other ':') (Lit_LBracket '[') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\\\'>) (/) 
                                                          (Lit_RBracket ']') (Lit_Star '*')
                                                        }
                                                      ]
                                                      action: [
                                                        (command.ShAssignment
                                                          pairs: [
                                                            (assign_pair
                                                              lhs: (sh_lhs_expr.Name name:abs)
                                                              op: Equal
                                                              rhs: {($ VSub_DollarName '$lib')}
                                                            )
                                                          ]
                                                        )
                                                      ]
                                                    )
                                                    (case_arm
                                                      pat_list: [{(Lit_Star '*')}]
                                                      action: [
                                                        (command.ShAssignment
                                                          pairs: [
                                                            (assign_pair
                                                              lhs: (sh_lhs_expr.Name name:abs)
                                                              op: Equal
                                                              rhs: 
                                                                {
                                                                  (command_sub
                                                                    left_token: <Left_Backtick '`'>
                                                                    command_list: 
                                                                      (command.CommandList
                                                                        children: [(C {(pwd)})]
                                                                      )
                                                                  ) (DQ (/) ($ VSub_DollarName '$lib'))
                                                                }
                                                            )
                                                          ]
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                )
                                                (C {(func_append)} {(newdlprefiles)} 
                                                  {(DQ (' ') ($ VSub_DollarName '$abs'))}
                                                )
                                              ]
                                            )
                                        )
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:dlprefiles)
                                              op: Equal
                                              rhs: {($ VSub_DollarName '$newdlprefiles')}
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                    (C {($ VSub_DollarName '$RM')} {($ VSub_DollarName '$output')})
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:tdlname)
                                          op: Equal
                                          rhs: {($ VSub_DollarName '$dlname')}
                                        )
                                      ]
                                    )
                                    (command.Case
                                      to_match: 
                                        {($ VSub_DollarName '$host') (Lit_Comma ',') 
                                          ($ VSub_DollarName '$output') (Lit_Comma ',') ($ VSub_DollarName '$installed') (Lit_Comma ',') ($ VSub_DollarName '$module') 
                                          (Lit_Comma ',') ($ VSub_DollarName '$dlname')
                                        }
                                      arms: [
                                        (case_arm
                                          pat_list: [
                                            {(Lit_Star '*') (cygwin) (Lit_Star '*') (Lit_Comma ',') 
                                              (Lit_Star '*') (lai) (Lit_Comma ',') (yes) (Lit_Comma ',') (no) (Lit_Comma ',') (Lit_Star '*') (.dll)
                                            }
                                            {(Lit_Star '*') (mingw) (Lit_Star '*') (Lit_Comma ',') 
                                              (Lit_Star '*') (lai) (Lit_Comma ',') (yes) (Lit_Comma ',') (no) (Lit_Comma ',') (Lit_Star '*') (.dll)
                                            }
                                            {(Lit_Star '*') (cegcc) (Lit_Star '*') (Lit_Comma ',') 
                                              (Lit_Star '*') (lai) (Lit_Comma ',') (yes) (Lit_Comma ',') (no) (Lit_Comma ',') (Lit_Star '*') (.dll)
                                            }
                                          ]
                                          action: [
                                            (command.If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (command.Sentence
                                                      child: 
                                                        (C {(test)} {(-n)} 
                                                          {(DQ ($ VSub_DollarName '$bindir'))}
                                                        )
                                                      terminator: <Op_Semi ';'>
                                                    )
                                                  ]
                                                  action: [
                                                    (C {(func_relative_path)} 
                                                      {(DQ ($ VSub_DollarName '$install_libdir'))} {(DQ ($ VSub_DollarName '$bindir'))}
                                                    )
                                                    (command.ShAssignment
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (sh_lhs_expr.Name name:tdlname)
                                                          op: Equal
                                                          rhs: 
                                                            {
                                                              ($ VSub_DollarName 
'$func_relative_path_result'
                                                              ) (/) ($ VSub_DollarName '$dlname')
                                                            }
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                )
                                              ]
                                              else_action: [
                                                (command.ShAssignment
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (sh_lhs_expr.Name name:tdlname)
                                                      op: Equal
                                                      rhs: {(../bin/) ($ VSub_DollarName '$dlname')}
                                                    )
                                                  ]
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                    (command.Simple
                                      words: [
                                        {($ VSub_DollarName '$ECHO')}
                                        {
                                          (DQ ('# ') ($ VSub_DollarName '$outputname') 
                                            (' - a libtool library file\n') ('# Generated by ') ($ VSub_DollarName '$PROGRAM') (' (GNU ') ($ VSub_DollarName '$PACKAGE') (') ') 
                                            ($ VSub_DollarName '$VERSION') ('\n') ('#\n') ('# Please DO NOT delete this file!\n') ('# It is necessary for linking the library.\n') 
                                            ('\n') ('# The name that we can dlopen(3).\n') ("dlname='") ($ VSub_DollarName '$tdlname') ("'\n") ('\n') 
                                            ('# Names of this library.\n') ("library_names='") ($ VSub_DollarName '$library_names') ("'\n") ('\n') 
                                            ('# The name of the static archive.\n') ("old_library='") ($ VSub_DollarName '$old_library') ("'\n") ('\n') 
                                            ('# Linker flags that cannot go in dependency_libs.\n') ("inherited_linker_flags='") ($ VSub_DollarName '$new_inherited_linker_flags') ("'\n") ('\n') 
                                            ('# Libraries that this one depends upon.\n') ("dependency_libs='") ($ VSub_DollarName '$dependency_libs') ("'\n") ('\n') 
                                            (
'# Names of additional weak libraries provided by this library\n'
                                            ) ("weak_library_names='") ($ VSub_DollarName '$weak_libs') ("'\n") ('\n') ('# Version information for ') 
                                            ($ VSub_DollarName '$libname') ('.\n') ('current=') ($ VSub_DollarName '$current') ('\n') ('age=') ($ VSub_DollarName '$age') ('\n') 
                                            ('revision=') ($ VSub_DollarName '$revision') ('\n') ('\n') ('# Is this an already installed library?\n') 
                                            ('installed=') ($ VSub_DollarName '$installed') ('\n') ('\n') 
                                            (
'# Should we warn about portability when linking against -modules?\n'
                                            ) ('shouldnotlink=') ($ VSub_DollarName '$module') ('\n') ('\n') ('# Files to dlopen/dlpreopen\n') 
                                            ("dlopen='") ($ VSub_DollarName '$dlfiles') ("'\n") ("dlpreopen='") ($ VSub_DollarName '$dlprefiles') ("'\n") ('\n') 
                                            (
'# Directory that this library needs to be installed in:\n'
                                            ) ("libdir='") ($ VSub_DollarName '$install_libdir') ("'")
                                          )
                                        }
                                      ]
                                      redirects: [
                                        (redir.Redir
                                          op: <Redir_Great '>'>
                                          fd: 16777215
                                          arg_word: {($ VSub_DollarName '$output')}
                                        )
                                      ]
                                    )
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (command.Sentence
                                              child: 
                                                (C {(test)} {(no) (Lit_Comma ',') (yes)} 
                                                  {(Lit_Equals '=')} {(DQ ($ VSub_DollarName '$installed') (',') ($ VSub_DollarName '$need_relink'))}
                                                )
                                              terminator: <Op_Semi ';'>
                                            )
                                          ]
                                          action: [
                                            (command.Simple
                                              words: [
                                                {($ VSub_DollarName '$ECHO')}
                                                {
                                                  (DQ ('relink_command=') 
                                                    (word_part.EscapedLiteral
                                                      token: <Lit_EscapedChar '\\"'>
                                                    ) ($ VSub_DollarName '$relink_command') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>)
                                                  )
                                                }
                                              ]
                                              redirects: [
                                                (redir.Redir
                                                  op: <Redir_DGreat '>>'>
                                                  fd: 16777215
                                                  arg_word: {($ VSub_DollarName '$output')}
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                  ]
                                )
                            )
                          ]
                        )
                      ]
                    )
                    (C {(func_show_eval)} 
                      {
                        (SQ 
                          <
'( cd "$output_objdir" && $RM "$outputname" && $LN_S "../$outputname" "$outputname" )'
                          >
                        )
                      } {(SQ <'exit $?'>)}
                    )
                  ]
                )
              ]
            )
            (command.ControlFlow
              token: <ControlFlow_Exit exit>
              arg_word: {($ VSub_DollarName '$EXIT_SUCCESS')}
            )
          ]
        )
    )
    (command.If
      arms: [
        (if_arm
          cond: [
            (command.Sentence
              child: 
                (command.AndOr
                  ops: [Op_DPipe]
                  children: [
                    (C {(test)} {(link)} {(Lit_Equals '=')} {(DQ ($ VSub_DollarName '$opt_mode'))})
                    (C {(test)} {(relink)} {(Lit_Equals '=')} {(DQ ($ VSub_DollarName '$opt_mode'))})
                  ]
                )
              terminator: <Op_Semi ';'>
            )
          ]
          action: [
            (C {(func_mode_link)} 
              {
                (braced_var_sub
                  token: <VSub_Number 1>
                  suffix_op: (suffix_op.Unary op_id:VTest_Plus arg_word:{(DQ ($ VSub_At '$@'))})
                )
              }
            )
          ]
        )
      ]
    )
    (command.ShFunction
      name: func_mode_uninstall
      body: 
        (command.BraceGroup
          children: [
            (C {($ VSub_DollarName '$debug_cmd')})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:RM)
                  op: Equal
                  rhs: {($ VSub_DollarName '$nonopt')}
                )
              ]
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:files) op:Equal rhs:(word.Empty))]
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:rmforce) op:Equal rhs:{(false)})]
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:exit_status) op:Equal rhs:{(0)})]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:libtool_install_magic)
                  op: Equal
                  rhs: {($ VSub_DollarName '$magic')}
                )
              ]
            )
            (command.ForEach
              iter_name: arg
              do_arg_iter: T
              body: 
                (command.DoGroup
                  children: [
                    (command.Case
                      to_match: {($ VSub_DollarName '$arg')}
                      arms: [
                        (case_arm
                          pat_list: [{(-f)}]
                          action: [
                            (command.Sentence
                              child: (C {(func_append)} {(RM)} {(DQ (' ') ($ VSub_DollarName '$arg'))})
                              terminator: <Op_Semi ';'>
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:rmforce)
                                  op: Equal
                                  rhs: {(Lit_Other ':')}
                                )
                              ]
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(-) (Lit_Star '*')}]
                          action: [(C {(func_append)} {(RM)} {(DQ (' ') ($ VSub_DollarName '$arg'))})]
                        )
                        (case_arm
                          pat_list: [{(Lit_Star '*')}]
                          action: [(C {(func_append)} {(files)} {(DQ (' ') ($ VSub_DollarName '$arg'))})]
                        )
                      ]
                    )
                  ]
                )
            )
            (command.AndOr
              ops: [Op_DAmp]
              children: [
                (C {(test)} {(-z)} {(DQ ($ VSub_DollarName '$RM'))})
                (C {(func_fatal_help)} {(DQ ('you must specify an RM program'))})
              ]
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:rmdirs) op:Equal rhs:(word.Empty))]
            )
            (command.ForEach
              iter_name: file
              iter_words: [{($ VSub_DollarName '$files')}]
              do_arg_iter: F
              body: 
                (command.DoGroup
                  children: [
                    (C {(func_dirname)} {(DQ ($ VSub_DollarName '$file'))} {(DQ )} {(DQ (.))})
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:dir)
                          op: Equal
                          rhs: {($ VSub_DollarName '$func_dirname_result')}
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: 
                                (C {(test)} {(.)} {(Lit_Equals '=')} {(DQ ($ VSub_DollarName '$dir'))})
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:odir)
                                  op: Equal
                                  rhs: {($ VSub_DollarName '$objdir')}
                                )
                              ]
                            )
                          ]
                        )
                      ]
                      else_action: [
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:odir)
                              op: Equal
                              rhs: {($ VSub_DollarName '$dir') (/) ($ VSub_DollarName '$objdir')}
                            )
                          ]
                        )
                      ]
                    )
                    (C {(func_basename)} {(DQ ($ VSub_DollarName '$file'))})
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:name)
                          op: Equal
                          rhs: {($ VSub_DollarName '$func_basename_result')}
                        )
                      ]
                    )
                    (command.AndOr
                      ops: [Op_DAmp]
                      children: [
                        (C {(test)} {(uninstall)} {(Lit_Equals '=')} 
                          {(DQ ($ VSub_DollarName '$opt_mode'))}
                        )
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:odir)
                              op: Equal
                              rhs: {($ VSub_DollarName '$dir')}
                            )
                          ]
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: 
                                (C {(test)} {(clean)} {(Lit_Equals '=')} 
                                  {(DQ ($ VSub_DollarName '$opt_mode'))}
                                )
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [
                            (command.Case
                              to_match: {(DQ (' ') ($ VSub_DollarName '$rmdirs') (' '))}
                              arms: [
                                (case_arm
                                  pat_list: [
                                    {(Lit_Star '*') (DQ (' ') ($ VSub_DollarName '$odir') (' ')) 
                                      (Lit_Star '*')
                                    }
                                  ]
                                )
                                (case_arm
                                  pat_list: [{(Lit_Star '*')}]
                                  action: [
                                    (C {(func_append)} {(rmdirs)} 
                                      {(DQ (' ') ($ VSub_DollarName '$odir'))}
                                    )
                                  ]
                                )
                              ]
                            )
                          ]
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: 
                                (command.AndOr
                                  ops: [Op_DPipe Op_DPipe]
                                  children: [
                                    (command.BraceGroup
                                      children: [
                                        (command.Sentence
                                          child: (C {(test)} {(-L)} {(DQ ($ VSub_DollarName '$file'))})
                                          terminator: <Op_Semi ';'>
                                        )
                                      ]
                                      redirects: [
                                        (redir.Redir
                                          op: <Redir_Great '>'>
                                          fd: 16777215
                                          arg_word: {(/dev/null)}
                                        )
                                        (redir.Redir
                                          op: <Redir_GreatAnd '2>&'>
                                          fd: 2
                                          arg_word: {(1)}
                                        )
                                      ]
                                    )
                                    (command.BraceGroup
                                      children: [
                                        (command.Sentence
                                          child: (C {(test)} {(-h)} {(DQ ($ VSub_DollarName '$file'))})
                                          terminator: <Op_Semi ';'>
                                        )
                                      ]
                                      redirects: [
                                        (redir.Redir
                                          op: <Redir_Great '>'>
                                          fd: 16777215
                                          arg_word: {(/dev/null)}
                                        )
                                        (redir.Redir
                                          op: <Redir_GreatAnd '2>&'>
                                          fd: 2
                                          arg_word: {(1)}
                                        )
                                      ]
                                    )
                                    (C {(test)} {(-f)} {(DQ ($ VSub_DollarName '$file'))})
                                  ]
                                )
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [(C {(Lit_Other ':')})]
                        )
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: (C {(test)} {(-d)} {(DQ ($ VSub_DollarName '$file'))})
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:exit_status)
                                  op: Equal
                                  rhs: {(1)}
                                )
                              ]
                            )
                            (command.ControlFlow
                              token: <ControlFlow_Continue continue>
                            )
                          ]
                        )
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: (C {($ VSub_DollarName '$rmforce')})
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [(command.ControlFlow token:<ControlFlow_Continue continue>)]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:rmfiles)
                          op: Equal
                          rhs: {($ VSub_DollarName '$file')}
                        )
                      ]
                    )
                    (command.Case
                      to_match: {($ VSub_DollarName '$name')}
                      arms: [
                        (case_arm
                          pat_list: [{(Lit_Star '*') (.la)}]
                          action: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: (C {(func_lalib_p)} {(DQ ($ VSub_DollarName '$file'))})
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (C {(func_source)} 
                                      {($ VSub_DollarName '$dir') (/) ($ VSub_DollarName '$name')}
                                    )
                                    (command.ForEach
                                      iter_name: n
                                      iter_words: [{($ VSub_DollarName '$library_names')}]
                                      do_arg_iter: F
                                      body: 
                                        (command.DoGroup
                                          children: [
                                            (C {(func_append)} {(rmfiles)} 
                                              {
                                                (DQ (' ') ($ VSub_DollarName '$odir') (/) 
                                                  ($ VSub_DollarName '$n')
                                                )
                                              }
                                            )
                                          ]
                                        )
                                    )
                                    (command.AndOr
                                      ops: [Op_DAmp]
                                      children: [
                                        (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$old_library'))})
                                        (C {(func_append)} {(rmfiles)} 
                                          {
                                            (DQ (' ') ($ VSub_DollarName '$odir') (/) 
                                              ($ VSub_DollarName '$old_library')
                                            )
                                          }
                                        )
                                      ]
                                    )
                                    (command.Case
                                      to_match: {($ VSub_DollarName '$opt_mode')}
                                      arms: [
                                        (case_arm
                                          pat_list: [{(clean)}]
                                          action: [
                                            (command.Case
                                              to_match: 
                                                {
                                                  (DQ (' ') ($ VSub_DollarName '$library_names') (' '))
                                                }
                                              arms: [
                                                (case_arm
                                                  pat_list: [
                                                    {(Lit_Star '*') 
                                                      (DQ (' ') ($ VSub_DollarName '$dlname') (' ')) (Lit_Star '*')
                                                    }
                                                  ]
                                                )
                                                (case_arm
                                                  pat_list: [{(Lit_Star '*')}]
                                                  action: [
                                                    (command.AndOr
                                                      ops: [Op_DAmp]
                                                      children: [
                                                        (C {(test)} {(-n)} 
                                                          {(DQ ($ VSub_DollarName '$dlname'))}
                                                        )
                                                        (C {(func_append)} {(rmfiles)} 
                                                          {
                                                            (DQ (' ') ($ VSub_DollarName '$odir') (/) 
                                                              ($ VSub_DollarName '$dlname')
                                                            )
                                                          }
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                )
                                              ]
                                            )
                                            (command.AndOr
                                              ops: [Op_DAmp]
                                              children: [
                                                (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$libdir'))})
                                                (C {(func_append)} {(rmfiles)} 
                                                  {
                                                    (DQ (' ') ($ VSub_DollarName '$odir') (/) 
                                                      ($ VSub_DollarName '$name') (' ') ($ VSub_DollarName '$odir') (/) (${ VSub_Name name) (i)
                                                    )
                                                  }
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                        (case_arm
                                          pat_list: [{(uninstall)}]
                                          action: [
                                            (command.If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (command.Sentence
                                                      child: 
                                                        (C {(test)} {(-n)} 
                                                          {(DQ ($ VSub_DollarName '$library_names'))}
                                                        )
                                                      terminator: <Op_Semi ';'>
                                                    )
                                                  ]
                                                  action: [
                                                    (C {(func_execute_cmds)} 
                                                      {(DQ ($ VSub_DollarName '$postuninstall_cmds'))} {(SQ <'$rmforce || exit_status=1'>)}
                                                    )
                                                  ]
                                                )
                                              ]
                                            )
                                            (command.If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (command.Sentence
                                                      child: 
                                                        (C {(test)} {(-n)} 
                                                          {(DQ ($ VSub_DollarName '$old_library'))}
                                                        )
                                                      terminator: <Op_Semi ';'>
                                                    )
                                                  ]
                                                  action: [
                                                    (C {(func_execute_cmds)} 
                                                      {
                                                        (DQ 
                                                          ($ VSub_DollarName 
'$old_postuninstall_cmds'
                                                          )
                                                        )
                                                      } {(SQ <'$rmforce || exit_status=1'>)}
                                                    )
                                                  ]
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(Lit_Star '*') (.lo)}]
                          action: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: (C {(func_lalib_p)} {(DQ ($ VSub_DollarName '$file'))})
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (C {(func_source)} 
                                      {($ VSub_DollarName '$dir') (/) ($ VSub_DollarName '$name')}
                                    )
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (command.Sentence
                                              child: 
                                                (command.AndOr
                                                  ops: [Op_DAmp]
                                                  children: [
                                                    (C {(test)} {(-n)} 
                                                      {(DQ ($ VSub_DollarName '$pic_object'))}
                                                    )
                                                    (C {(test)} {(none)} 
                                                      {(KW_Bang '!') (Lit_Equals '=')} {(DQ ($ VSub_DollarName '$pic_object'))}
                                                    )
                                                  ]
                                                )
                                              terminator: <Op_Semi ';'>
                                            )
                                          ]
                                          action: [
                                            (C {(func_append)} {(rmfiles)} 
                                              {
                                                (DQ (' ') ($ VSub_DollarName '$dir') (/) 
                                                  ($ VSub_DollarName '$pic_object')
                                                )
                                              }
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (command.Sentence
                                              child: 
                                                (command.AndOr
                                                  ops: [Op_DAmp]
                                                  children: [
                                                    (C {(test)} {(-n)} 
                                                      {(DQ ($ VSub_DollarName '$non_pic_object'))}
                                                    )
                                                    (C {(test)} {(none)} 
                                                      {(KW_Bang '!') (Lit_Equals '=')} {(DQ ($ VSub_DollarName '$non_pic_object'))}
                                                    )
                                                  ]
                                                )
                                              terminator: <Op_Semi ';'>
                                            )
                                          ]
                                          action: [
                                            (C {(func_append)} {(rmfiles)} 
                                              {
                                                (DQ (' ') ($ VSub_DollarName '$dir') (/) 
                                                  ($ VSub_DollarName '$non_pic_object')
                                                )
                                              }
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(Lit_Star '*')}]
                          action: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (C {(test)} {(clean)} {(Lit_Equals '=')} 
                                          {(DQ ($ VSub_DollarName '$opt_mode'))}
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:noexename)
                                          op: Equal
                                          rhs: {($ VSub_DollarName '$name')}
                                        )
                                      ]
                                    )
                                    (command.Case
                                      to_match: {($ VSub_DollarName '$file')}
                                      arms: [
                                        (case_arm
                                          pat_list: [{(Lit_Star '*') (.exe)}]
                                          action: [
                                            (C {(func_stripname)} {(SQ )} {(SQ <.exe>)} 
                                              {(DQ ($ VSub_DollarName '$file'))}
                                            )
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:file)
                                                  op: Equal
                                                  rhs: {($ VSub_DollarName '$func_stripname_result')}
                                                )
                                              ]
                                            )
                                            (C {(func_stripname)} {(SQ )} {(SQ <.exe>)} 
                                              {(DQ ($ VSub_DollarName '$name'))}
                                            )
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:noexename)
                                                  op: Equal
                                                  rhs: {($ VSub_DollarName '$func_stripname_result')}
                                                )
                                              ]
                                            )
                                            (C {(func_append)} {(rmfiles)} 
                                              {(DQ (' ') ($ VSub_DollarName '$file'))}
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (command.Sentence
                                              child: 
                                                (C {(func_ltwrapper_p)} 
                                                  {(DQ ($ VSub_DollarName '$file'))}
                                                )
                                              terminator: <Op_Semi ';'>
                                            )
                                          ]
                                          action: [
                                            (command.If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (command.Sentence
                                                      child: 
                                                        (C {(func_ltwrapper_executable_p)} 
                                                          {(DQ ($ VSub_DollarName '$file'))}
                                                        )
                                                      terminator: <Op_Semi ';'>
                                                    )
                                                  ]
                                                  action: [
                                                    (C {(func_ltwrapper_scriptname)} 
                                                      {(DQ ($ VSub_DollarName '$file'))}
                                                    )
                                                    (command.ShAssignment
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (sh_lhs_expr.Name name:relink_command)
                                                          op: Equal
                                                          rhs: (word.Empty)
                                                        )
                                                      ]
                                                    )
                                                    (C {(func_source)} 
                                                      {
                                                        ($ VSub_DollarName 
'$func_ltwrapper_scriptname_result'
                                                        )
                                                      }
                                                    )
                                                    (C {(func_append)} {(rmfiles)} 
                                                      {
                                                        (DQ (' ') 
                                                          ($ VSub_DollarName 
'$func_ltwrapper_scriptname_result'
                                                          )
                                                        )
                                                      }
                                                    )
                                                  ]
                                                )
                                              ]
                                              else_action: [
                                                (command.ShAssignment
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (sh_lhs_expr.Name name:relink_command)
                                                      op: Equal
                                                      rhs: (word.Empty)
                                                    )
                                                  ]
                                                )
                                                (C {(func_source)} 
                                                  {($ VSub_DollarName '$dir') (/) 
                                                    ($ VSub_DollarName '$noexename')
                                                  }
                                                )
                                              ]
                                            )
                                            (C {(func_append)} {(rmfiles)} 
                                              {
                                                (DQ (' ') ($ VSub_DollarName '$odir') (/) 
                                                  ($ VSub_DollarName '$name') (' ') ($ VSub_DollarName '$odir') (/) (${ VSub_Name name) (S.) ($ VSub_DollarName '$objext')
                                                )
                                              }
                                            )
                                            (command.If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (command.Sentence
                                                      child: 
                                                        (command.AndOr
                                                          ops: [Op_DAmp]
                                                          children: [
                                                            (C {(test)} {(yes)} {(Lit_Equals '=')} 
                                                              {
                                                                (DQ 
                                                                  ($ VSub_DollarName '$fast_install')
                                                                )
                                                              }
                                                            )
                                                            (C {(test)} {(-n)} 
                                                              {
                                                                (DQ 
                                                                  ($ VSub_DollarName 
'$relink_command'
                                                                  )
                                                                )
                                                              }
                                                            )
                                                          ]
                                                        )
                                                      terminator: <Op_Semi ';'>
                                                    )
                                                  ]
                                                  action: [
                                                    (C {(func_append)} {(rmfiles)} 
                                                      {
                                                        (DQ (' ') ($ VSub_DollarName '$odir') (/lt-) 
                                                          ($ VSub_DollarName '$name')
                                                        )
                                                      }
                                                    )
                                                  ]
                                                )
                                              ]
                                            )
                                            (command.If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (command.Sentence
                                                      child: 
                                                        (C {(test)} 
                                                          {(DQ (X) ($ VSub_DollarName '$noexename'))} {(KW_Bang '!') (Lit_Equals '=')} {(DQ (X) ($ VSub_DollarName '$name'))}
                                                        )
                                                      terminator: <Op_Semi ';'>
                                                    )
                                                  ]
                                                  action: [
                                                    (C {(func_append)} {(rmfiles)} 
                                                      {
                                                        (DQ (' ') ($ VSub_DollarName '$odir') (/lt-) 
                                                          ($ VSub_DollarName '$noexename') (.c)
                                                        )
                                                      }
                                                    )
                                                  ]
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                            )
                          ]
                        )
                      ]
                    )
                    (C {(func_show_eval)} 
                      {(DQ ($ VSub_DollarName '$RM') (' ') ($ VSub_DollarName '$rmfiles'))} {(SQ <'exit_status=1'>)}
                    )
                  ]
                )
            )
            (command.ForEach
              iter_name: dir
              iter_words: [{($ VSub_DollarName '$rmdirs')}]
              do_arg_iter: F
              body: 
                (command.DoGroup
                  children: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: (C {(test)} {(-d)} {(DQ ($ VSub_DollarName '$dir'))})
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [
                            (C {(func_show_eval)} 
                              {(DQ ('rmdir ') ($ VSub_DollarName '$dir') (' >/dev/null 2>&1'))}
                            )
                          ]
                        )
                      ]
                    )
                  ]
                )
            )
            (command.ControlFlow
              token: <ControlFlow_Exit exit>
              arg_word: {($ VSub_DollarName '$exit_status')}
            )
          ]
        )
    )
    (command.If
      arms: [
        (if_arm
          cond: [
            (command.Sentence
              child: 
                (command.AndOr
                  ops: [Op_DPipe]
                  children: [
                    (C {(test)} {(uninstall)} {(Lit_Equals '=')} {(DQ ($ VSub_DollarName '$opt_mode'))})
                    (C {(test)} {(clean)} {(Lit_Equals '=')} {(DQ ($ VSub_DollarName '$opt_mode'))})
                  ]
                )
              terminator: <Op_Semi ';'>
            )
          ]
          action: [
            (C {(func_mode_uninstall)} 
              {
                (braced_var_sub
                  token: <VSub_Number 1>
                  suffix_op: (suffix_op.Unary op_id:VTest_Plus arg_word:{(DQ ($ VSub_At '$@'))})
                )
              }
            )
          ]
        )
      ]
    )
    (command.AndOr
      ops: [Op_DAmp]
      children: [
        (C {(test)} {(-z)} {(DQ ($ VSub_DollarName '$opt_mode'))})
        (command.BraceGroup
          children: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:help)
                  op: Equal
                  rhs: {($ VSub_DollarName '$generic_help')}
                )
              ]
            )
            (C {(func_fatal_help)} {(DQ ('you must specify a MODE'))})
          ]
        )
      ]
    )
    (command.AndOr
      ops: [Op_DAmp]
      children: [
        (C {(test)} {(-z)} {(DQ ($ VSub_DollarName '$exec_cmd'))})
        (C {(func_fatal_help)} {(DQ ("invalid operation mode '") ($ VSub_DollarName '$opt_mode') ("'"))})
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: [
            (command.Sentence
              child: (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$exec_cmd'))})
              terminator: <Op_Semi ';'>
            )
          ]
          action: [
            (C {(eval)} {(exec)} {(DQ ($ VSub_DollarName '$exec_cmd'))})
            (command.ControlFlow
              token: <ControlFlow_Exit exit>
              arg_word: {($ VSub_DollarName '$EXIT_FAILURE')}
            )
          ]
        )
      ]
    )
    (command.ControlFlow
      token: <ControlFlow_Exit exit>
      arg_word: {($ VSub_DollarName '$exit_status')}
    )
    (command.ShAssignment
      pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:build_libtool_libs) op:Equal rhs:{(no)})]
    )
    (command.ShAssignment
      pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:build_old_libs) op:Equal rhs:{(yes)})]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:build_old_libs)
          op: Equal
          rhs: 
            {
              (command_sub
                left_token: <Left_Backtick '`'>
                command_list: 
                  (command.CommandList
                    children: [
                      (command.Case
                        to_match: {($ VSub_DollarName '$build_libtool_libs')}
                        arms: [
                          (case_arm
                            pat_list: [{(yes)}]
                            action: [(C {(echo)} {(no)})]
                          )
                          (case_arm
                            pat_list: [{(Lit_Star '*')}]
                            action: [(C {(echo)} {(yes)})]
                          )
                        ]
                      )
                    ]
                  )
              )
            }
        )
      ]
    )
  ]
)