########################################################################
#                                                                      #
#               This software is part of the ast package               #
#          Copyright (c) 1987-2011 AT&T Intellectual Property          #
#                      and is licensed under the                       #
#                 Eclipse Public License, Version 1.0                  #
#                    by AT&T Intellectual Property                     #
#                                                                      #
#                A copy of the License is available at                 #
#          http://www.eclipse.org/org/documents/epl-v10.html           #
#         (with md5 checksum b35adb5213ca9657e911e9befb180842)         #
#                                                                      #
#              Information and Software Systems Research               #
#                            AT&T Research                             #
#                           Florham Park NJ                            #
#                                                                      #
#                 Glenn Fowler <gsf@research.att.com>                  #
#                                                                      #
########################################################################
: tw + pax for backup
#
# @(#)bax (AT&T Bell Laboratories) 05/09/95
#
# ../lib/bax/init on $PATH to customize
#

global command := 'bax'
global customize := "../lib/$(command)/init"

#
# no stinking environment
#

global root := '', arch_name := '', arch_keep := '', big_size := '', big_magic_keep := ''
global name_skip := '', path_skip := '', reg_magic_skip := '', src_name := '', src_magic_skip := ''

global ifs := $(IFS-'
	 ')
global IFS := ':'
global path := $PATH
global IFS := $ifs
for dir in [$path]
{	if	test -f $dir/$customize
	{	source $dir/$customize
		break
	}
}

#
# default dirs
#

global root := $(root:-'/')

#
# keep these architecture specific files: */${arch_name}/*/${arch_keep}
#

global arch_name := $(arch_name:-'arch')
global arch_keep := $(arch_keep:-'bin|fun|lib')

#
# files bigger than ${big_size} must have magic that matches ${big_magic_keep}
#

global big_size := $(big_size:-5000000)
global big_magic_keep := $(big_magic_keep:-'mail')

#
# ${name_skip} are base names to be skipped
# ${path_skip} are path prefixes to be skipped
#

global name_skip := $(name_skip:-'?(*.)(old|save|tmp)?(.*)|.*-cache')
global path_skip := $(path_skip:-'/dev|/usr/local/ast/ship')

#
# regular files with magic that matches ${reg_magic_skip} are skipped
#

global reg_magic_skip := $(reg_magic_skip:-'core|cql * index|history|TeX dvi')

#
# files under */${src_name}/* are skipped if magic matches ${src_magic_skip}
#

global src_name := $(src_name:-'src')
global src_magic_skip := $(src_magic_skip:-'executable|object|(archive|shared) library')

matchstr $Argc {
[01] {	echo "Usage: $command delta base [dir ...]" > !2
	exit 2
	}
}
global delta := $1
shift
global base := $2
shift
matchstr $Argc {
0 {	set $root }
}
global dirs := ''
while	:
{	matchstr $Argc {
	0 {	break }
	}
	global dirs := ""$dirs -d $1""
	shift
}

tw $dirs -mH -e "

begin:	int	arch_bit = 1;
	int	src_bit = 2;
	char*	m;

sort:	name;

select:	if (name == '$(name_skip)')
		status = SKIP;
	else if (type == REG)
	{
		m = magic;
		if (size > $(big_size) && m != '*@($(big_magic_keep))*' ||
		    m == '*@($(reg_magic_skip))*' ||
		    (parent.local & src_bit) && m == '*@($(src_magic_skip))*')
			status = SKIP;
	}
	else if (type == DIR)
	{
		local = (parent.local & src_bit);
		if (dev != parent.dev || path == '$(path_skip)' || (parent.parent.local & arch_bit) && name != '$(arch_keep)')
			status = SKIP;
		else if (name == '$(arch_name)')
			local |= arch_bit;
		else if (name == '$(src_name)')
			local |= src_bit;
	}
	return 1;
" | pax -o "write ordered physical verbose file=$delta base=$base"
(CommandList
  children: [
    (C {(Lit_Other ":")} {(tw)} {(Lit_Other "+")} {(pax)} {(KW_For for)} {(backup)})
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:command) op:Equal rhs:{(bax)} spids:[85])]
      spids: [85]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:customize)
          op: Equal
          rhs: {(../lib/) (${ VSub_Name command) (/init)}
          spids: [88]
        )
      ]
      spids: [88]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair lhs:(LhsName name:root) op:Equal rhs:{(SQ )} spids:[106])
        (assign_pair lhs:(LhsName name:arch_name) op:Equal rhs:{(SQ )} spids:[108])
        (assign_pair lhs:(LhsName name:arch_keep) op:Equal rhs:{(SQ )} spids:[110])
        (assign_pair lhs:(LhsName name:big_size) op:Equal rhs:{(SQ )} spids:[112])
        (assign_pair lhs:(LhsName name:big_magic_keep) op:Equal rhs:{(SQ )} spids:[114])
      ]
      spids: [106]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair lhs:(LhsName name:name_skip) op:Equal rhs:{(SQ )} spids:[116])
        (assign_pair lhs:(LhsName name:path_skip) op:Equal rhs:{(SQ )} spids:[118])
        (assign_pair lhs:(LhsName name:reg_magic_skip) op:Equal rhs:{(SQ )} spids:[120])
        (assign_pair lhs:(LhsName name:src_name) op:Equal rhs:{(SQ )} spids:[122])
        (assign_pair lhs:(LhsName name:src_magic_skip) op:Equal rhs:{(SQ )} spids:[124])
      ]
      spids: [116]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:ifs)
          op: Equal
          rhs: 
            {
              (BracedVarSub
                token: <VSub_Name IFS>
                suffix_op: (StringUnary op_id:VTest_Hyphen arg_word:{(SQ <"\n"> <"\t ">)})
                spids: [128 135]
              )
            }
          spids: [127]
        )
      ]
      spids: [127]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:IFS) op:Equal rhs:{(Lit_Other ":")} spids:[137])]
      spids: [137]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:path) op:Equal rhs:{($ VSub_Name "$PATH")} spids:[140])]
      spids: [140]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:IFS) op:Equal rhs:{($ VSub_Name "$ifs")} spids:[143])]
      spids: [143]
    )
    (ForEach
      iter_name: dir
      iter_words: [{($ VSub_Name "$path")}]
      do_arg_iter: False
      body: 
        (DoGroup
          children: [
            (If
              arms: [
                (if_arm
                  cond: [(C {(test)} {(-f)} {($ VSub_Name "$dir") (/) ($ VSub_Name "$customize")})]
                  action: [
                    (C {(.)} {($ VSub_Name "$dir") (/) ($ VSub_Name "$customize")})
                    (ControlFlow token:<ControlFlow_Break break>)
                  ]
                  spids: [-1 167]
                )
              ]
              spids: [-1 179]
            )
          ]
          spids: [154 181]
        )
      spids: [151 -1]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:root)
          op: Equal
          rhs: 
            {
              (BracedVarSub
                token: <VSub_Name root>
                suffix_op: (StringUnary op_id:VTest_ColonHyphen arg_word:{(SQ </>)})
                spids: [195 201]
              )
            }
          spids: [194]
        )
      ]
      spids: [194]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:arch_name)
          op: Equal
          rhs: 
            {
              (BracedVarSub
                token: <VSub_Name arch_name>
                suffix_op: (StringUnary op_id:VTest_ColonHyphen arg_word:{(SQ <arch>)})
                spids: [215 221]
              )
            }
          spids: [214]
        )
      ]
      spids: [214]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:arch_keep)
          op: Equal
          rhs: 
            {
              (BracedVarSub
                token: <VSub_Name arch_keep>
                suffix_op: (StringUnary op_id:VTest_ColonHyphen arg_word:{(SQ <"bin|fun|lib">)})
                spids: [224 230]
              )
            }
          spids: [223]
        )
      ]
      spids: [223]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:big_size)
          op: Equal
          rhs: 
            {
              (BracedVarSub
                token: <VSub_Name big_size>
                suffix_op: (StringUnary op_id:VTest_ColonHyphen arg_word:{(5000000)})
                spids: [244 248]
              )
            }
          spids: [243]
        )
      ]
      spids: [243]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:big_magic_keep)
          op: Equal
          rhs: 
            {
              (BracedVarSub
                token: <VSub_Name big_magic_keep>
                suffix_op: (StringUnary op_id:VTest_ColonHyphen arg_word:{(SQ <mail>)})
                spids: [251 257]
              )
            }
          spids: [250]
        )
      ]
      spids: [250]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:name_skip)
          op: Equal
          rhs: 
            {
              (BracedVarSub
                token: <VSub_Name name_skip>
                suffix_op: 
                  (StringUnary
                    op_id: VTest_ColonHyphen
                    arg_word: {(SQ <"?(*.)(old|save|tmp)?(.*)|.*-cache">)}
                  )
                spids: [274 280]
              )
            }
          spids: [273]
        )
      ]
      spids: [273]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:path_skip)
          op: Equal
          rhs: 
            {
              (BracedVarSub
                token: <VSub_Name path_skip>
                suffix_op: 
                  (StringUnary
                    op_id: VTest_ColonHyphen
                    arg_word: {(SQ <"/dev|/usr/local/ast/ship">)}
                  )
                spids: [283 289]
              )
            }
          spids: [282]
        )
      ]
      spids: [282]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:reg_magic_skip)
          op: Equal
          rhs: 
            {
              (BracedVarSub
                token: <VSub_Name reg_magic_skip>
                suffix_op: 
                  (StringUnary
                    op_id: VTest_ColonHyphen
                    arg_word: {(SQ <"core|cql * index|history|TeX dvi">)}
                  )
                spids: [303 309]
              )
            }
          spids: [302]
        )
      ]
      spids: [302]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:src_name)
          op: Equal
          rhs: 
            {
              (BracedVarSub
                token: <VSub_Name src_name>
                suffix_op: (StringUnary op_id:VTest_ColonHyphen arg_word:{(SQ <src>)})
                spids: [323 329]
              )
            }
          spids: [322]
        )
      ]
      spids: [322]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:src_magic_skip)
          op: Equal
          rhs: 
            {
              (BracedVarSub
                token: <VSub_Name src_magic_skip>
                suffix_op: 
                  (StringUnary
                    op_id: VTest_ColonHyphen
                    arg_word: {(SQ <"executable|object|(archive|shared) library">)}
                  )
                spids: [332 338]
              )
            }
          spids: [331]
        )
      ]
      spids: [331]
    )
    (Case
      to_match: {($ VSub_Pound "$#")}
      arms: [
        (case_arm
          pat_list: [{(Lit_Other "[") (01) (Lit_Other "]")}]
          action: [
            (SimpleCommand
              words: [{(echo)} {(DQ ("Usage: ") ($ VSub_Name "$command") (" delta base [dir ...]"))}]
              redirects: [(Redir op_id:Redir_GreatAnd fd:-1 arg_word:{(2)} spids:[360])]
            )
            (C {(exit)} {(2)})
          ]
          spids: [347 350 369 -1]
        )
      ]
      spids: [341 345 371]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:delta) op:Equal rhs:{($ VSub_Number "$1")} spids:[373])]
      spids: [373]
    )
    (C {(shift)})
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:base) op:Equal rhs:{($ VSub_Number "$2")} spids:[378])]
      spids: [378]
    )
    (C {(shift)})
    (Case
      to_match: {($ VSub_Pound "$#")}
      arms: [
        (case_arm
          pat_list: [{(0)}]
          action: [(C {(set)} {($ VSub_Name "$root")})]
          spids: [389 390 396 -1]
        )
      ]
      spids: [383 387 398]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:dirs) op:Equal rhs:{(SQ )} spids:[400])]
      spids: [400]
    )
    (While
      cond: [(C {(Lit_Other ":")})]
      body: 
        (DoGroup
          children: [
            (Case
              to_match: {($ VSub_Pound "$#")}
              arms: [
                (case_arm
                  pat_list: [{(0)}]
                  action: [(ControlFlow token:<ControlFlow_Break break>)]
                  spids: [415 416 420 -1]
                )
              ]
              spids: [408 412 423]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:dirs)
                  op: Equal
                  rhs: {(DQ ($ VSub_Name "$dirs") (" -d ") ($ VSub_Number "$1"))}
                  spids: [426]
                )
              ]
              spids: [426]
            )
            (C {(shift)})
          ]
          spids: [406 436]
        )
    )
    (Pipeline
      children: [
        (C {(tw)} {($ VSub_Name "$dirs")} {(-mH)} {(-e)} 
          {
            (DQ ("\n") ("\n") ("begin:\tint\tarch_bit = 1;\n") ("\tint\tsrc_bit = 2;\n") 
              ("\tchar*\tm;\n") ("\n") ("sort:\tname;\n") ("\n") ("select:\tif (name == '") (${ VSub_Name name_skip) ("')\n") 
              ("\t\tstatus = SKIP;\n") ("\telse if (type == REG)\n") ("\t{\n") ("\t\tm = magic;\n") ("\t\tif (size > ") (${ VSub_Name big_size) 
              (" && m != '*@(") (${ VSub_Name big_magic_keep) (")*' ||\n") ("\t\t    m == '*@(") (${ VSub_Name reg_magic_skip) 
              (")*' ||\n") ("\t\t    (parent.local & src_bit) && m == '*@(") (${ VSub_Name src_magic_skip) (")*')\n") 
              ("\t\t\tstatus = SKIP;\n") ("\t}\n") ("\telse if (type == DIR)\n") ("\t{\n") ("\t\tlocal = (parent.local & src_bit);\n") 
              ("\t\tif (dev != parent.dev || path == '") (${ VSub_Name path_skip) ("' || (parent.parent.local & arch_bit) && name != '") 
              (${ VSub_Name arch_keep) ("')\n") ("\t\t\tstatus = SKIP;\n") ("\t\telse if (name == '") (${ VSub_Name arch_name) ("')\n") 
              ("\t\t\tlocal |= arch_bit;\n") ("\t\telse if (name == '") (${ VSub_Name src_name) ("')\n") ("\t\t\tlocal |= src_bit;\n") ("\t}\n") 
              ("\treturn 1;\n")
            )
          }
        )
        (C {(pax)} {(-o)} 
          {
            (DQ ("write ordered physical verbose file=") ($ VSub_Name "$delta") (" base=") 
              ($ VSub_Name "$base")
            )
          }
        )
      ]
      negated: False
    )
  ]
)