#!/bin/sh

# This script copies source file lists from src/Makefile.am to cmake files.

proc get_variable_value {
  var FILENAME = $1
  var VARNAME = $2
  awk "
    BEGIN { start = 0; }
    /^$VARNAME =/ { start = 1; }
    { if (start) { print \$0; } }
    /\\\\\$/ { next; }
    { start = 0; }
  " $FILENAME \
    | sed "s/^$VARNAME =//" \
    | sed "s/[ \\]//g" \
    | grep -v "^\\$" \
    | grep -v "^$" \
    | env LC_ALL=C sort | uniq
}

proc get_header_files {
  get_variable_value $ifsjoin(Argv) | grep '\.h$'
}

proc get_source_files {
  get_variable_value $ifsjoin(Argv) | grep "cc$"
}

proc get_proto_files_blacklisted {
  get_proto_files $ifsjoin(Argv) | sed '/^google\/protobuf\/unittest_enormous_descriptor.proto$/d'
}

proc get_proto_files {
  get_variable_value $ifsjoin(Argv) | grep "pb.cc$" | sed "s/pb.cc/proto/"
}

proc sort_files {
  for FILE in [$ifsjoin(Argv)] {
    echo $FILE
  } | env LC_ALL=C sort | uniq
}

global MAKEFILE := 'src/Makefile.am'

test -f $MAKEFILE || do {
  echo "Cannot find: $MAKEFILE"
  exit 1
}

# Extract file lists from src/Makefile.am
global GZHEADERS := $[get_variable_value $MAKEFILE GZHEADERS]
global HEADERS := $[get_variable_value $MAKEFILE nobase_include_HEADERS]
global PUBLIC_HEADERS := $[sort_files $GZHEADERS $HEADERS]
global LIBPROTOBUF_LITE_SOURCES := $[get_source_files $MAKEFILE libprotobuf_lite_la_SOURCES]
global LIBPROTOBUF_SOURCES := $[get_source_files $MAKEFILE libprotobuf_la_SOURCES]
global LIBPROTOC_SOURCES := $[get_source_files $MAKEFILE libprotoc_la_SOURCES]
global LITE_PROTOS := $[get_proto_files $MAKEFILE protoc_lite_outputs]
global PROTOS := $[get_proto_files $MAKEFILE protoc_outputs]
global PROTOS_BLACKLISTED := $[get_proto_files_blacklisted $MAKEFILE protoc_outputs]
global WKT_PROTOS := $[get_variable_value $MAKEFILE nobase_dist_proto_DATA]
global COMMON_TEST_SOURCES := $[get_source_files $MAKEFILE COMMON_TEST_SOURCES]
global COMMON_LITE_TEST_SOURCES := $[get_source_files $MAKEFILE COMMON_LITE_TEST_SOURCES]
global TEST_SOURCES := $[get_source_files $MAKEFILE protobuf_test_SOURCES]
global LITE_TEST_SOURCES := $[get_source_files $MAKEFILE protobuf_lite_test_SOURCES]
global LITE_ARENA_TEST_SOURCES := $[get_source_files $MAKEFILE protobuf_lite_arena_test_SOURCES]
global TEST_PLUGIN_SOURCES := $[get_source_files $MAKEFILE test_plugin_SOURCES]

################################################################################
# Update cmake files.
################################################################################

global CMAKE_DIR := 'cmake'
global EXTRACT_INCLUDES_BAT := 'cmake/extract_includes.bat.in'
test -d $CMAKE_DIR || do {
  echo "Cannot find: $CMAKE_DIR"
  exit 1
}

test -f $EXTRACT_INCLUDES_BAT || do {
  echo "Cannot find: $EXTRACT_INCLUDES_BAT"
  exit 1
}

proc set_cmake_value {
  var FILENAME = $1
  var VARNAME = $2
  var PREFIX = $3
  shift
  shift
  shift
  awk -v values="$ifsjoin(Argv)" -v prefix="$PREFIX" "
    BEGIN { start = 0; }
    /^set\\($VARNAME/ {
      start = 1;
      print \$0;
      len = split(values, vlist, \" \");
      for (i = 1; i <= len; ++i) {
        printf(\"  %s%s\\n\", prefix, vlist[i]);
      }
      next;
    }
    start && /^\\)/ {
      start = 0;
    }
    !start {
      print \$0;
    }
  " $FILENAME > /tmp/$Pid
  cp /tmp/$Pid $FILENAME
}


# Replace file lists in cmake files.
global CMAKE_PREFIX := '"\${protobuf_source_dir}/src/'"
set_cmake_value $CMAKE_DIR/libprotobuf-lite.cmake libprotobuf_lite_files $CMAKE_PREFIX $LIBPROTOBUF_LITE_SOURCES
set_cmake_value $CMAKE_DIR/libprotobuf.cmake libprotobuf_files $CMAKE_PREFIX $LIBPROTOBUF_SOURCES
set_cmake_value $CMAKE_DIR/libprotoc.cmake libprotoc_files $CMAKE_PREFIX $LIBPROTOC_SOURCES
set_cmake_value $CMAKE_DIR/tests.cmake lite_test_protos "" $LITE_PROTOS
set_cmake_value $CMAKE_DIR/tests.cmake tests_protos "" $PROTOS_BLACKLISTED
set_cmake_value $CMAKE_DIR/tests.cmake common_test_files $CMAKE_PREFIX $COMMON_TEST_SOURCES
set_cmake_value $CMAKE_DIR/tests.cmake common_lite_test_files $CMAKE_PREFIX $COMMON_LITE_TEST_SOURCES
set_cmake_value $CMAKE_DIR/tests.cmake tests_files $CMAKE_PREFIX $TEST_SOURCES
set_cmake_value $CMAKE_DIR/tests.cmake lite_test_files $CMAKE_PREFIX $LITE_TEST_SOURCES
set_cmake_value $CMAKE_DIR/tests.cmake lite_arena_test_files $CMAKE_PREFIX $LITE_ARENA_TEST_SOURCES

# Generate extract_includes.bat
echo "mkdir include" > $EXTRACT_INCLUDES_BAT
for HEADER in [$PUBLIC_HEADERS] {
  global HEADER_DIR := $[dirname $HEADER]
  while [ ! "$HEADER_DIR" = "." ] {
    echo $HEADER_DIR | sed "s/\\//\\\\/g"
    global HEADER_DIR := $[dirname $HEADER_DIR]
  }
} | sort | uniq | sed "s/^/mkdir include\\\\/" >> $EXTRACT_INCLUDES_BAT
for HEADER in [$PUBLIC_HEADERS] {
  global WINPATH := $[echo $HEADER | sed 's;/;\\;g]
  echo "copy \${PROTOBUF_SOURCE_WIN32_PATH}\\..\\src\\$WINPATH include\\$WINPATH" >> $EXTRACT_INCLUDES_BAT
}

################################################################################
# Update bazel BUILD files.
################################################################################

proc set_bazel_value {
  var FILENAME = $1
  var VARNAME = $2
  var PREFIX = $3
  shift
  shift
  shift
  awk -v values="$ifsjoin(Argv)" -v prefix="$PREFIX" "
    BEGIN { start = 0; }
    /# AUTOGEN\\($VARNAME\\)/ {
      start = 1;
      print \$0;
      # replace \$0 with indent.
      sub(/#.*/, \"\", \$0)
      len = split(values, vlist, \" \");
      for (i = 1; i <= len; ++i) {
        printf(\"%s\\\"%s%s\\\",\n\", \$0, prefix, vlist[i]);
      }
      next;
    }
    start && /\]/ {
      start = 0
    }
    !start {
      print \$0;
    }
  " $FILENAME > /tmp/$Pid
  cp /tmp/$Pid $FILENAME
}


global BAZEL_BUILD := './BUILD'
global BAZEL_PREFIX := '"src/'"
if test -f $BAZEL_BUILD {
  set_bazel_value $BAZEL_BUILD protobuf_lite_srcs $BAZEL_PREFIX $LIBPROTOBUF_LITE_SOURCES
  set_bazel_value $BAZEL_BUILD protobuf_srcs $BAZEL_PREFIX $LIBPROTOBUF_SOURCES
  set_bazel_value $BAZEL_BUILD protoc_lib_srcs $BAZEL_PREFIX $LIBPROTOC_SOURCES
  set_bazel_value $BAZEL_BUILD lite_test_protos "" $LITE_PROTOS
  set_bazel_value $BAZEL_BUILD well_known_protos "" $WKT_PROTOS
  set_bazel_value $BAZEL_BUILD test_protos "" $PROTOS
  set_bazel_value $BAZEL_BUILD common_test_srcs $BAZEL_PREFIX $COMMON_TEST_SOURCES
  set_bazel_value $BAZEL_BUILD test_srcs $BAZEL_PREFIX $TEST_SOURCES
  set_bazel_value $BAZEL_BUILD test_plugin_srcs $BAZEL_PREFIX $TEST_PLUGIN_SOURCES
} else {
  echo "Skipped BUILD file update."
}

(CommandList
  children: [
    (FuncDef
      name: get_variable_value
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_Local
              pairs: [
                (assign_pair
                  lhs: (LhsName name:FILENAME)
                  op: Equal
                  rhs: {($ VSub_Number "$1")}
                  spids: [17]
                )
              ]
              spids: [15]
            )
            (Assignment
              keyword: Assign_Local
              pairs: [
                (assign_pair
                  lhs: (LhsName name:VARNAME)
                  op: Equal
                  rhs: {($ VSub_Number "$2")}
                  spids: [23]
                )
              ]
              spids: [21]
            )
            (Pipeline
              children: [
                (C {(awk)} 
                  {
                    (DQ ("\n") ("    BEGIN { start = 0; }\n") ("    /^") ($ VSub_Name "$VARNAME") 
                      (" =/ { start = 1; }\n") ("    { if (start) { print ") (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) ("0; } }\n") ("    /") 
                      (EscapedLiteralPart token:<Lit_EscapedChar "\\\\">) (EscapedLiteralPart token:<Lit_EscapedChar "\\\\">) (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) 
                      ("/ { next; }\n") ("    { start = 0; }\n") ("  ")
                    )
                  } {($ VSub_Name "$FILENAME")}
                )
                (C {(sed)} {(DQ ("s/^") ($ VSub_Name "$VARNAME") (" =//"))})
                (C {(sed)} {(DQ ("s/[ ") (EscapedLiteralPart token:<Lit_EscapedChar "\\\\">) ("]//g"))})
                (C {(grep)} {(-v)} 
                  {(DQ ("^") (EscapedLiteralPart token:<Lit_EscapedChar "\\\\">) (Lit_Other "$"))}
                )
                (C {(grep)} {(-v)} {(DQ ("^") (Lit_Other "$"))})
                (SimpleCommand
                  words: [{(sort)}]
                  more_env: [(env_pair name:LC_ALL val:{(C)} spids:[104])]
                )
                (C {(uniq)})
              ]
              negated: False
            )
          ]
          spids: [12]
        )
      spids: [8 11]
    )
    (FuncDef
      name: get_header_files
      body: 
        (BraceGroup
          children: [
            (Pipeline
              children: [(C {(get_variable_value)} {($ VSub_At "$@")}) (C {(grep)} {(SQ <"\\.h$">)})]
              negated: False
            )
          ]
          spids: [120]
        )
      spids: [116 119]
    )
    (FuncDef
      name: get_source_files
      body: 
        (BraceGroup
          children: [
            (Pipeline
              children: [
                (C {(get_variable_value)} {($ VSub_At "$@")})
                (C {(grep)} {(DQ (cc) (Lit_Other "$"))})
              ]
              negated: False
            )
          ]
          spids: [142]
        )
      spids: [138 141]
    )
    (FuncDef
      name: get_proto_files_blacklisted
      body: 
        (BraceGroup
          children: [
            (Pipeline
              children: [
                (C {(get_proto_files)} {($ VSub_At "$@")})
                (C {(sed)} {(SQ <"/^google\\/protobuf\\/unittest_enormous_descriptor.proto$/d">)})
              ]
              negated: False
            )
          ]
          spids: [165]
        )
      spids: [161 164]
    )
    (FuncDef
      name: get_proto_files
      body: 
        (BraceGroup
          children: [
            (Pipeline
              children: [
                (C {(get_variable_value)} {($ VSub_At "$@")})
                (C {(grep)} {(DQ (pb.cc) (Lit_Other "$"))})
                (C {(sed)} {(DQ (s/pb.cc/proto/))})
              ]
              negated: False
            )
          ]
          spids: [187]
        )
      spids: [183 186]
    )
    (FuncDef
      name: sort_files
      body: 
        (BraceGroup
          children: [
            (Pipeline
              children: [
                (ForEach
                  iter_name: FILE
                  iter_words: [{($ VSub_At "$@")}]
                  do_arg_iter: False
                  body: (DoGroup children:[(C {(echo)} {($ VSub_Name "$FILE")})] spids:[230238])
                  spids: [226 228]
                )
                (SimpleCommand
                  words: [{(sort)}]
                  more_env: [(env_pair name:LC_ALL val:{(C)} spids:[242])]
                )
                (C {(uniq)})
              ]
              negated: False
            )
          ]
          spids: [218]
        )
      spids: [214 217]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:MAKEFILE) op:Equal rhs:{(src/Makefile.am)} spids:[254])]
      spids: [254]
    )
    (AndOr
      children: [
        (C {(Lit_Other "[")} {(-f)} {(DQ ($ VSub_Name "$MAKEFILE"))} {(Lit_Other "]")})
        (BraceGroup
          children: [(C {(echo)} {(DQ ("Cannot find: ") ($ VSub_Name "$MAKEFILE"))}) (C {(exit)} {(1)})]
          spids: [270]
        )
      ]
      op_id: Op_DPipe
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:GZHEADERS)
          op: Equal
          rhs: 
            {
              (CommandSubPart
                command_list: 
                  (CommandList
                    children: [(C {(get_variable_value)} {($ VSub_Name "$MAKEFILE")} {(GZHEADERS)})]
                  )
                left_token: <Left_CommandSub "$(">
                spids: [292 298]
              )
            }
          spids: [291]
        )
      ]
      spids: [291]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:HEADERS)
          op: Equal
          rhs: 
            {
              (CommandSubPart
                command_list: 
                  (CommandList
                    children: [
                      (C {(get_variable_value)} {($ VSub_Name "$MAKEFILE")} {(nobase_include_HEADERS)})
                    ]
                  )
                left_token: <Left_CommandSub "$(">
                spids: [301 307]
              )
            }
          spids: [300]
        )
      ]
      spids: [300]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:PUBLIC_HEADERS)
          op: Equal
          rhs: 
            {
              (CommandSubPart
                command_list: 
                  (CommandList
                    children: [
                      (C {(sort_files)} {($ VSub_Name "$GZHEADERS")} {($ VSub_Name "$HEADERS")})
                    ]
                  )
                left_token: <Left_CommandSub "$(">
                spids: [310 316]
              )
            }
          spids: [309]
        )
      ]
      spids: [309]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:LIBPROTOBUF_LITE_SOURCES)
          op: Equal
          rhs: 
            {
              (CommandSubPart
                command_list: 
                  (CommandList
                    children: [
                      (C {(get_source_files)} {($ VSub_Name "$MAKEFILE")} 
                        {(libprotobuf_lite_la_SOURCES)}
                      )
                    ]
                  )
                left_token: <Left_CommandSub "$(">
                spids: [319 325]
              )
            }
          spids: [318]
        )
      ]
      spids: [318]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:LIBPROTOBUF_SOURCES)
          op: Equal
          rhs: 
            {
              (CommandSubPart
                command_list: 
                  (CommandList
                    children: [
                      (C {(get_source_files)} {($ VSub_Name "$MAKEFILE")} {(libprotobuf_la_SOURCES)})
                    ]
                  )
                left_token: <Left_CommandSub "$(">
                spids: [328 334]
              )
            }
          spids: [327]
        )
      ]
      spids: [327]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:LIBPROTOC_SOURCES)
          op: Equal
          rhs: 
            {
              (CommandSubPart
                command_list: 
                  (CommandList
                    children: [
                      (C {(get_source_files)} {($ VSub_Name "$MAKEFILE")} {(libprotoc_la_SOURCES)})
                    ]
                  )
                left_token: <Left_CommandSub "$(">
                spids: [337 343]
              )
            }
          spids: [336]
        )
      ]
      spids: [336]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:LITE_PROTOS)
          op: Equal
          rhs: 
            {
              (CommandSubPart
                command_list: 
                  (CommandList
                    children: [
                      (C {(get_proto_files)} {($ VSub_Name "$MAKEFILE")} {(protoc_lite_outputs)})
                    ]
                  )
                left_token: <Left_CommandSub "$(">
                spids: [346 352]
              )
            }
          spids: [345]
        )
      ]
      spids: [345]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:PROTOS)
          op: Equal
          rhs: 
            {
              (CommandSubPart
                command_list: 
                  (CommandList
                    children: [(C {(get_proto_files)} {($ VSub_Name "$MAKEFILE")} {(protoc_outputs)})]
                  )
                left_token: <Left_CommandSub "$(">
                spids: [355 361]
              )
            }
          spids: [354]
        )
      ]
      spids: [354]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:PROTOS_BLACKLISTED)
          op: Equal
          rhs: 
            {
              (CommandSubPart
                command_list: 
                  (CommandList
                    children: [
                      (C {(get_proto_files_blacklisted)} {($ VSub_Name "$MAKEFILE")} {(protoc_outputs)})
                    ]
                  )
                left_token: <Left_CommandSub "$(">
                spids: [364 370]
              )
            }
          spids: [363]
        )
      ]
      spids: [363]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:WKT_PROTOS)
          op: Equal
          rhs: 
            {
              (CommandSubPart
                command_list: 
                  (CommandList
                    children: [
                      (C {(get_variable_value)} {($ VSub_Name "$MAKEFILE")} {(nobase_dist_proto_DATA)})
                    ]
                  )
                left_token: <Left_CommandSub "$(">
                spids: [373 379]
              )
            }
          spids: [372]
        )
      ]
      spids: [372]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:COMMON_TEST_SOURCES)
          op: Equal
          rhs: 
            {
              (CommandSubPart
                command_list: 
                  (CommandList
                    children: [
                      (C {(get_source_files)} {($ VSub_Name "$MAKEFILE")} {(COMMON_TEST_SOURCES)})
                    ]
                  )
                left_token: <Left_CommandSub "$(">
                spids: [382 388]
              )
            }
          spids: [381]
        )
      ]
      spids: [381]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:COMMON_LITE_TEST_SOURCES)
          op: Equal
          rhs: 
            {
              (CommandSubPart
                command_list: 
                  (CommandList
                    children: [
                      (C {(get_source_files)} {($ VSub_Name "$MAKEFILE")} {(COMMON_LITE_TEST_SOURCES)})
                    ]
                  )
                left_token: <Left_CommandSub "$(">
                spids: [391 397]
              )
            }
          spids: [390]
        )
      ]
      spids: [390]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:TEST_SOURCES)
          op: Equal
          rhs: 
            {
              (CommandSubPart
                command_list: 
                  (CommandList
                    children: [
                      (C {(get_source_files)} {($ VSub_Name "$MAKEFILE")} {(protobuf_test_SOURCES)})
                    ]
                  )
                left_token: <Left_CommandSub "$(">
                spids: [400 406]
              )
            }
          spids: [399]
        )
      ]
      spids: [399]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:LITE_TEST_SOURCES)
          op: Equal
          rhs: 
            {
              (CommandSubPart
                command_list: 
                  (CommandList
                    children: [
                      (C {(get_source_files)} {($ VSub_Name "$MAKEFILE")} {(protobuf_lite_test_SOURCES)})
                    ]
                  )
                left_token: <Left_CommandSub "$(">
                spids: [409 415]
              )
            }
          spids: [408]
        )
      ]
      spids: [408]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:LITE_ARENA_TEST_SOURCES)
          op: Equal
          rhs: 
            {
              (CommandSubPart
                command_list: 
                  (CommandList
                    children: [
                      (C {(get_source_files)} {($ VSub_Name "$MAKEFILE")} 
                        {(protobuf_lite_arena_test_SOURCES)}
                      )
                    ]
                  )
                left_token: <Left_CommandSub "$(">
                spids: [418 424]
              )
            }
          spids: [417]
        )
      ]
      spids: [417]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:TEST_PLUGIN_SOURCES)
          op: Equal
          rhs: 
            {
              (CommandSubPart
                command_list: 
                  (CommandList
                    children: [
                      (C {(get_source_files)} {($ VSub_Name "$MAKEFILE")} {(test_plugin_SOURCES)})
                    ]
                  )
                left_token: <Left_CommandSub "$(">
                spids: [427 433]
              )
            }
          spids: [426]
        )
      ]
      spids: [426]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:CMAKE_DIR) op:Equal rhs:{(cmake)} spids:[446])]
      spids: [446]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:EXTRACT_INCLUDES_BAT)
          op: Equal
          rhs: {(cmake/extract_includes.bat.in)}
          spids: [449]
        )
      ]
      spids: [449]
    )
    (AndOr
      children: [
        (C {(Lit_Other "[")} {(-d)} {(DQ ($ VSub_Name "$CMAKE_DIR"))} {(Lit_Other "]")})
        (BraceGroup
          children: [(C {(echo)} {(DQ ("Cannot find: ") ($ VSub_Name "$CMAKE_DIR"))}) (C {(exit)} {(1)})]
          spids: [464]
        )
      ]
      op_id: Op_DPipe
    )
    (AndOr
      children: [
        (C {(Lit_Other "[")} {(-f)} {(DQ ($ VSub_Name "$EXTRACT_INCLUDES_BAT"))} {(Lit_Other "]")})
        (BraceGroup
          children: [
            (C {(echo)} {(DQ ("Cannot find: ") ($ VSub_Name "$EXTRACT_INCLUDES_BAT"))})
            (C {(exit)} {(1)})
          ]
          spids: [494]
        )
      ]
      op_id: Op_DPipe
    )
    (FuncDef
      name: set_cmake_value
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_Local
              pairs: [
                (assign_pair
                  lhs: (LhsName name:FILENAME)
                  op: Equal
                  rhs: {($ VSub_Number "$1")}
                  spids: [521]
                )
              ]
              spids: [519]
            )
            (Assignment
              keyword: Assign_Local
              pairs: [
                (assign_pair
                  lhs: (LhsName name:VARNAME)
                  op: Equal
                  rhs: {($ VSub_Number "$2")}
                  spids: [527]
                )
              ]
              spids: [525]
            )
            (Assignment
              keyword: Assign_Local
              pairs: [
                (assign_pair
                  lhs: (LhsName name:PREFIX)
                  op: Equal
                  rhs: {($ VSub_Number "$3")}
                  spids: [533]
                )
              ]
              spids: [531]
            )
            (C {(shift)})
            (C {(shift)})
            (C {(shift)})
            (SimpleCommand
              words: [
                {(awk)}
                {(-v)}
                {(Lit_VarLike "values=") (DQ ($ VSub_Star "$*"))}
                {(-v)}
                {(Lit_VarLike "prefix=") (DQ ($ VSub_Name "$PREFIX"))}
                {
                  (DQ ("\n") ("    BEGIN { start = 0; }\n") ("    /^set") 
                    (EscapedLiteralPart token:<Lit_EscapedChar "\\\\">) ("(") ($ VSub_Name "$VARNAME") ("/ {\n") ("      start = 1;\n") ("      print ") 
                    (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) ("0;\n") ("      len = split(values, vlist, ") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) (" ") 
                    (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) (");\n") ("      for (i = 1; i <= len; ++i) {\n") ("        printf(") 
                    (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) ("  %s%s") (EscapedLiteralPart token:<Lit_EscapedChar "\\\\">) (n) 
                    (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) (", prefix, vlist[i]);\n") ("      }\n") ("      next;\n") ("    }\n") ("    start && /^") 
                    (EscapedLiteralPart token:<Lit_EscapedChar "\\\\">) (")/ {\n") ("      start = 0;\n") ("    }\n") ("    !start {\n") ("      print ") 
                    (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) ("0;\n") ("    }\n") ("  ")
                  )
                }
                {($ VSub_Name "$FILENAME")}
              ]
              redirects: [
                (Redir
                  op_id: Redir_Great
                  fd: -1
                  arg_word: {(/tmp/) ($ VSub_Dollar "$$")}
                  spids: [605]
                )
              ]
            )
            (C {(cp)} {(/tmp/) ($ VSub_Dollar "$$")} {($ VSub_Name "$FILENAME")})
          ]
          spids: [516]
        )
      spids: [512 515]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:CMAKE_PREFIX)
          op: Equal
          rhs: {(DQ (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) ("{protobuf_source_dir}/src/"))}
          spids: [625]
        )
      ]
      spids: [625]
    )
    (C {(set_cmake_value)} {($ VSub_Name "$CMAKE_DIR") (/libprotobuf-lite.cmake)} 
      {(libprotobuf_lite_files)} {($ VSub_Name "$CMAKE_PREFIX")} {($ VSub_Name "$LIBPROTOBUF_LITE_SOURCES")}
    )
    (C {(set_cmake_value)} {($ VSub_Name "$CMAKE_DIR") (/libprotobuf.cmake)} {(libprotobuf_files)} 
      {($ VSub_Name "$CMAKE_PREFIX")} {($ VSub_Name "$LIBPROTOBUF_SOURCES")}
    )
    (C {(set_cmake_value)} {($ VSub_Name "$CMAKE_DIR") (/libprotoc.cmake)} {(libprotoc_files)} 
      {($ VSub_Name "$CMAKE_PREFIX")} {($ VSub_Name "$LIBPROTOC_SOURCES")}
    )
    (C {(set_cmake_value)} {($ VSub_Name "$CMAKE_DIR") (/tests.cmake)} {(lite_test_protos)} {(DQ )} 
      {($ VSub_Name "$LITE_PROTOS")}
    )
    (C {(set_cmake_value)} {($ VSub_Name "$CMAKE_DIR") (/tests.cmake)} {(tests_protos)} {(DQ )} 
      {($ VSub_Name "$PROTOS_BLACKLISTED")}
    )
    (C {(set_cmake_value)} {($ VSub_Name "$CMAKE_DIR") (/tests.cmake)} {(common_test_files)} 
      {($ VSub_Name "$CMAKE_PREFIX")} {($ VSub_Name "$COMMON_TEST_SOURCES")}
    )
    (C {(set_cmake_value)} {($ VSub_Name "$CMAKE_DIR") (/tests.cmake)} {(common_lite_test_files)} 
      {($ VSub_Name "$CMAKE_PREFIX")} {($ VSub_Name "$COMMON_LITE_TEST_SOURCES")}
    )
    (C {(set_cmake_value)} {($ VSub_Name "$CMAKE_DIR") (/tests.cmake)} {(tests_files)} 
      {($ VSub_Name "$CMAKE_PREFIX")} {($ VSub_Name "$TEST_SOURCES")}
    )
    (C {(set_cmake_value)} {($ VSub_Name "$CMAKE_DIR") (/tests.cmake)} {(lite_test_files)} 
      {($ VSub_Name "$CMAKE_PREFIX")} {($ VSub_Name "$LITE_TEST_SOURCES")}
    )
    (C {(set_cmake_value)} {($ VSub_Name "$CMAKE_DIR") (/tests.cmake)} {(lite_arena_test_files)} 
      {($ VSub_Name "$CMAKE_PREFIX")} {($ VSub_Name "$LITE_ARENA_TEST_SOURCES")}
    )
    (SimpleCommand
      words: [{(echo)} {(DQ ("mkdir include"))}]
      redirects: [
        (Redir
          op_id: Redir_Great
          fd: -1
          arg_word: {($ VSub_Name "$EXTRACT_INCLUDES_BAT")}
          spids: [753]
        )
      ]
    )
    (Pipeline
      children: [
        (ForEach
          iter_name: HEADER
          iter_words: [{($ VSub_Name "$PUBLIC_HEADERS")}]
          do_arg_iter: False
          body: 
            (DoGroup
              children: [
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:HEADER_DIR)
                      op: Equal
                      rhs: 
                        {
                          (CommandSubPart
                            command_list: 
                              (CommandList
                                children: [(C {(dirname)} {($ VSub_Name "$HEADER")})]
                              )
                            left_token: <Left_CommandSub "$(">
                            spids: [770 774]
                          )
                        }
                      spids: [769]
                    )
                  ]
                  spids: [769]
                )
                (While
                  cond: [
                    (Sentence
                      child: 
                        (C {(Lit_Other "[")} {(KW_Bang "!")} {(DQ ($ VSub_Name "$HEADER_DIR"))} 
                          {(Lit_Other "=")} {(DQ (.))} {(Lit_Other "]")}
                        )
                      terminator: <Op_Semi ";">
                    )
                  ]
                  body: 
                    (DoGroup
                      children: [
                        (Pipeline
                          children: [
                            (C {(echo)} {($ VSub_Name "$HEADER_DIR")})
                            (C {(sed)} 
                              {
                                (DQ (s/) (EscapedLiteralPart token:<Lit_EscapedChar "\\\\">) (//) 
                                  (EscapedLiteralPart
                                    token: <Lit_EscapedChar "\\\\">
                                  ) (EscapedLiteralPart token:<Lit_EscapedChar "\\\\">) (/g)
                                )
                              }
                            )
                          ]
                          negated: False
                        )
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:HEADER_DIR)
                              op: Equal
                              rhs: 
                                {
                                  (CommandSubPart
                                    command_list: 
                                      (CommandList
                                        children: [(C {(dirname)} {($ VSub_Name "$HEADER_DIR")})]
                                      )
                                    left_token: <Left_CommandSub "$(">
                                    spids: [818 822]
                                  )
                                }
                              spids: [817]
                            )
                          ]
                          spids: [817]
                        )
                      ]
                      spids: [796 825]
                    )
                )
              ]
              spids: [766 827]
            )
          spids: [762 764]
        )
        (C {(sort)})
        (C {(uniq)})
        (SimpleCommand
          words: [
            {(sed)}
            {
              (DQ ("s/^/mkdir include") (EscapedLiteralPart token:<Lit_EscapedChar "\\\\">) 
                (EscapedLiteralPart token:<Lit_EscapedChar "\\\\">) (/)
              )
            }
          ]
          redirects: [
            (Redir
              op_id: Redir_DGreat
              fd: -1
              arg_word: {($ VSub_Name "$EXTRACT_INCLUDES_BAT")}
              spids: [848]
            )
          ]
        )
      ]
      negated: False
    )
    (ForEach
      iter_name: HEADER
      iter_words: [{($ VSub_Name "$PUBLIC_HEADERS")}]
      do_arg_iter: False
      body: 
        (DoGroup
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:WINPATH)
                  op: Equal
                  rhs: 
                    {
                      (CommandSubPart
                        command_list: 
                          (CommandList
                            children: [
                              (Pipeline
                                children: [
                                  (C {(echo)} {($ VSub_Name "$HEADER")})
                                  (C {(sed)} {(SQ <"s;/;\\\\;g">)})
                                ]
                                negated: False
                              )
                            ]
                          )
                        left_token: <Left_CommandSub "$(">
                        spids: [865 877]
                      )
                    }
                  spids: [864]
                )
              ]
              spids: [864]
            )
            (SimpleCommand
              words: [
                {(echo)}
                {
                  (DQ ("copy ") (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) 
                    ("{PROTOBUF_SOURCE_WIN32_PATH}") (EscapedLiteralPart token:<Lit_EscapedChar "\\\\">) (..) 
                    (EscapedLiteralPart token:<Lit_EscapedChar "\\\\">) (src) (EscapedLiteralPart token:<Lit_EscapedChar "\\\\">) ($ VSub_Name "$WINPATH") (" include") 
                    (EscapedLiteralPart token:<Lit_EscapedChar "\\\\">) ($ VSub_Name "$WINPATH")
                  )
                }
              ]
              redirects: [
                (Redir
                  op_id: Redir_DGreat
                  fd: -1
                  arg_word: {($ VSub_Name "$EXTRACT_INCLUDES_BAT")}
                  spids: [897]
                )
              ]
            )
          ]
          spids: [861 901]
        )
      spids: [857 859]
    )
    (FuncDef
      name: set_bazel_value
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_Local
              pairs: [
                (assign_pair
                  lhs: (LhsName name:FILENAME)
                  op: Equal
                  rhs: {($ VSub_Number "$1")}
                  spids: [923]
                )
              ]
              spids: [921]
            )
            (Assignment
              keyword: Assign_Local
              pairs: [
                (assign_pair
                  lhs: (LhsName name:VARNAME)
                  op: Equal
                  rhs: {($ VSub_Number "$2")}
                  spids: [929]
                )
              ]
              spids: [927]
            )
            (Assignment
              keyword: Assign_Local
              pairs: [
                (assign_pair
                  lhs: (LhsName name:PREFIX)
                  op: Equal
                  rhs: {($ VSub_Number "$3")}
                  spids: [935]
                )
              ]
              spids: [933]
            )
            (C {(shift)})
            (C {(shift)})
            (C {(shift)})
            (SimpleCommand
              words: [
                {(awk)}
                {(-v)}
                {(Lit_VarLike "values=") (DQ ($ VSub_Star "$*"))}
                {(-v)}
                {(Lit_VarLike "prefix=") (DQ ($ VSub_Name "$PREFIX"))}
                {
                  (DQ ("\n") ("    BEGIN { start = 0; }\n") ("    /# AUTOGEN") 
                    (EscapedLiteralPart token:<Lit_EscapedChar "\\\\">) ("(") ($ VSub_Name "$VARNAME") (EscapedLiteralPart token:<Lit_EscapedChar "\\\\">) (")/ {\n") 
                    ("      start = 1;\n") ("      print ") (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) ("0;\n") ("      # replace ") 
                    (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) ("0 with indent.\n") ("      sub(/#.*/, ") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) 
                    (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) (", ") (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) ("0)\n") ("      len = split(values, vlist, ") 
                    (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) (" ") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) (");\n") 
                    ("      for (i = 1; i <= len; ++i) {\n") ("        printf(") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) ("%s") 
                    (EscapedLiteralPart token:<Lit_EscapedChar "\\\\">) (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) ("%s%s") 
                    (EscapedLiteralPart token:<Lit_EscapedChar "\\\\">) (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) (",") 
                    (EscapedLiteralPart token:<Lit_EscapedChar "\\n">) (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) (", ") 
                    (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) ("0, prefix, vlist[i]);\n") ("      }\n") ("      next;\n") ("    }\n") ("    start && /") 
                    (EscapedLiteralPart token:<Lit_EscapedChar "\\]">) ("/ {\n") ("      start = 0\n") ("    }\n") ("    !start {\n") ("      print ") 
                    (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) ("0;\n") ("    }\n") ("  ")
                  )
                }
                {($ VSub_Name "$FILENAME")}
              ]
              redirects: [
                (Redir
                  op_id: Redir_Great
                  fd: -1
                  arg_word: {(/tmp/) ($ VSub_Dollar "$$")}
                  spids: [1024]
                )
              ]
            )
            (C {(cp)} {(/tmp/) ($ VSub_Dollar "$$")} {($ VSub_Name "$FILENAME")})
          ]
          spids: [918]
        )
      spids: [914 917]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:BAZEL_BUILD) op:Equal rhs:{(./BUILD)} spids:[1041])]
      spids: [1041]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:BAZEL_PREFIX) op:Equal rhs:{(DQ (src/))} spids:[1044])]
      spids: [1044]
    )
    (If
      arms: [
        (if_arm
          cond: [
            (Sentence
              child: (C {(Lit_Other "[")} {(-f)} {(DQ ($ VSub_Name "$BAZEL_BUILD"))} {(Lit_Other "]")})
              terminator: <Op_Semi ";">
            )
          ]
          action: [
            (C {(set_bazel_value)} {($ VSub_Name "$BAZEL_BUILD")} {(protobuf_lite_srcs)} 
              {($ VSub_Name "$BAZEL_PREFIX")} {($ VSub_Name "$LIBPROTOBUF_LITE_SOURCES")}
            )
            (C {(set_bazel_value)} {($ VSub_Name "$BAZEL_BUILD")} {(protobuf_srcs)} 
              {($ VSub_Name "$BAZEL_PREFIX")} {($ VSub_Name "$LIBPROTOBUF_SOURCES")}
            )
            (C {(set_bazel_value)} {($ VSub_Name "$BAZEL_BUILD")} {(protoc_lib_srcs)} 
              {($ VSub_Name "$BAZEL_PREFIX")} {($ VSub_Name "$LIBPROTOC_SOURCES")}
            )
            (C {(set_bazel_value)} {($ VSub_Name "$BAZEL_BUILD")} {(lite_test_protos)} {(DQ )} 
              {($ VSub_Name "$LITE_PROTOS")}
            )
            (C {(set_bazel_value)} {($ VSub_Name "$BAZEL_BUILD")} {(well_known_protos)} {(DQ )} 
              {($ VSub_Name "$WKT_PROTOS")}
            )
            (C {(set_bazel_value)} {($ VSub_Name "$BAZEL_BUILD")} {(test_protos)} {(DQ )} 
              {($ VSub_Name "$PROTOS")}
            )
            (C {(set_bazel_value)} {($ VSub_Name "$BAZEL_BUILD")} {(common_test_srcs)} 
              {($ VSub_Name "$BAZEL_PREFIX")} {($ VSub_Name "$COMMON_TEST_SOURCES")}
            )
            (C {(set_bazel_value)} {($ VSub_Name "$BAZEL_BUILD")} {(test_srcs)} 
              {($ VSub_Name "$BAZEL_PREFIX")} {($ VSub_Name "$TEST_SOURCES")}
            )
            (C {(set_bazel_value)} {($ VSub_Name "$BAZEL_BUILD")} {(test_plugin_srcs)} 
              {($ VSub_Name "$BAZEL_PREFIX")} {($ VSub_Name "$TEST_PLUGIN_SOURCES")}
            )
          ]
          spids: [-1 1062]
        )
      ]
      else_action: [(C {(echo)} {(DQ ("Skipped BUILD file update."))})]
      spids: [1166 1175]
    )
  ]
)