Note that bash's ;;& (added in 4.0 in 2009) is the equivalent of zsh's ;| (from 2007; also in mksh since 2011), it's not a fall through in the sense of C's fallthrough when you omit the break in a switch statement in that the next pattern will still be checked.

As in bash's

case a in (a) echo a;;& (b) echo b esac 

Or zsh's / mksh's

case a in (a) echo a;| (b) echo b esac 

Won't output both a and b like a

switch('a') { case 'a': puts("a"); /* fall through */ case 'b': puts("b"); } 

would in C.

For that, you'd need ;& instead (itself from ksh93 and found in all of bash, zsh and mksh; while ;; and the whole case...esac structure is from the Bourne shell from the late 70s).

Also, in bash's

case $string in (a*) echo starts with a;;& (*b) echo ends with b;; (*c*) echo neither starts with a nor ends in b but contains c esac 

That is if you mix ;;& and ;;, then you can't just do pattern matching in sequence independently as a standard equivalent.

In that example, the *c* case will only be reached if the string matches neither a* not *b.

One approach can be to do all 3 checks and then consider all combinations:

test1=0 test2=0 test3=0 case $string in (a*) test1=1 esac case $string in (*b) test2=1 esac case $string in (*c*) test3=1 esac case $test1$test2$test3 in (11?) echo starts with a echo ends in b;; (10?) echo start with a;; (01?) echo ends in b;; (??1) echo neither starts with a nor ends in b but contains c esac 

Or adapt on a case by case basis, using a combination of case and if and/or &&/||, like here:

flag=false case $string in (a*) echo starts with a flag=true esac case $string in (*b) echo ends in b flag=true esac "$flag" || case $string in (*c*) echo neither starts with a nor ends in b but contains c esac 

Or do it all with if/then/else, using flags or repeating the checks like in:

match() case $1 in ($2) true;; (*) false; esac if match "$string" 'a*'; then echo starts with a fi if match "$string" '*b'; then echo ends in a fi if ! match "$string" 'a*' && ! match "$string" '*b' && match "$string" '*c*' then echo neither starts with a nor ends in b but contains c fi 

Which may make it easier to follow.

With the use-case you've now added:

case $5 in (C | C++) export CXXFLAGS="${CXXFLAGS} ${1}${SUSUWU_DEPENDENCY_INCLUDE_PATH}" esac case $5 in (C) export CFLAGS="${CFLAGS} ${1}${SUSUWU_DEPENDENCY_INCLUDE_PATH}";; (C++) ;; (*) export FLAGS_USER="${FLAGS_USER} ${1}${SUSUWU_DEPENDENCY_INCLUDE_PATH}" esac 

Or:

c_or_cxx=false case $5 in (C) export CFLAGS="${CFLAGS} ${1}${SUSUWU_DEPENDENCY_INCLUDE_PATH}" c_or_cxx=true;; (C++) c_or_cxx=true;; (*) export FLAGS_USER="${FLAGS_USER} ${1}${SUSUWU_DEPENDENCY_INCLUDE_PATH}" esac if "$c_or_cxx"; then export CXXFLAGS="${CXXFLAGS} ${1}${SUSUWU_DEPENDENCY_INCLUDE_PATH}" fi 

You can also include the common code in a function or variable to eval (variable may be preferable here as the code includes references to $1):

for_c_and_cxx=' export CXXFLAGS="${CXXFLAGS} ${1}${SUSUWU_DEPENDENCY_INCLUDE_PATH}" ' case $5 in (C) export CFLAGS="${CFLAGS} ${1}${SUSUWU_DEPENDENCY_INCLUDE_PATH}" eval "$for_c_and_cxx";; (C++) eval "$for_c_and_cxx";; (*) export FLAGS_USER="${FLAGS_USER} {1}${SUSUWU_DEPENDENCY_INCLUDE_PATH}" esac 

Note that it's only the Bourne shell that required you omitted the opening (s (the Bourne shell also did not support export var=value and in any case was not a POSIX compliant shell). In modern/standard sh implementations, you can include it which IMO makes for more readable code and lets you use your editors ability to check for matching parenthesis for instance.

bash

var='fooo' case "$var" in foo*) echo 2 ;;& fooo*) echo 3 ;;& esac 

sh

case "$var" in foo*) echo 2 ;; esac case "$var" in fooo*) echo 3 ;; esac 

FWIW I'd keep it simple and use the case statement to decide what needs to happen and then a series of ifs to implement that desired behavior:

case "${5}" in #/* Language determines which flags to use */ "C") set_cflags=1; set_cxxflags=1 ;; "C++") set_cxxflags=1 ;; *) set_flags_user=1 ;; esac if [ "$set_cflags" = 1 ]; then export CFLAGS="${CFLAGS} ${1}${SUSUWU_DEPENDENCY_INCLUDE_PATH}" fi if [ "$set_cxxflags" = 1 ]; then export CXXFLAGS="${CXXFLAGS} ${1}${SUSUWU_DEPENDENCY_INCLUDE_PATH}" fi if [ "$set_flags_user" = 1 ]; then export FLAGS_USER="${FLAGS_USER} ${1}${SUSUWU_DEPENDENCY_INCLUDE_PATH}" fi 

I just read the POSIX spec and see POSIX shell supports functions so you could alternatively do:

set_cflags() { export CFLAGS="${CFLAGS} ${1}${SUSUWU_DEPENDENCY_INCLUDE_PATH}"; } set_cxxflags() { export CXXFLAGS="${CXXFLAGS} ${1}${SUSUWU_DEPENDENCY_INCLUDE_PATH}"; } set_flagsuser() { export FLAGS_USER="${FLAGS_USER} ${1}${SUSUWU_DEPENDENCY_INCLUDE_PATH}"; } case "${5}" in #/* Language determines which flags to use */ "C") set_cflags "$1"; set_cxxflags "$1";; "C++") set_cxxflags "$1";; *) set_flagsuser "$1";; esac 

In most languages a "case" or "switch" statement does not have a "fall-through". In C it's a low-level performance optimization for re-using common code, but you frequently get compiler warnings when using it. So if you have a lot of common code, consider to put that in a function, or replace the case with some if... [elif ...]... fi structure.