Home Switchboard Unix Administration Red Hat TCP/IP Networks Neoliberalism Toxic Managers May the source be with you, but remember the KISS principle ;-) Skepticism and critical thinking is not panacea, but can help to understand the world better

# Control Structures

Pseudoscientific sudo-religious junk propagated under the name of structured programming was one positive affect: it attracted attention and researchers to this field.

the most productive approach is to study real programs (or thier control graphs) and try to distill the set of control structures that is fundamental to programming. Unfortunatly this is a difficult task as control structures do not exist independently of the language

Study of program control grpohs is more productive approach.  In this domain the problem can be reformulated as the problem iof decomposition of a given contol flow grpah into primary components.  There are several classic approaches to recreation of  high level control structures from an assembler code based on program graph decomposition

Decomposition of program graph into "single entry-single exit" subgraphs (hammocks). All control in a hammock must be passed to the entry note called head and all control from the quants should pass via the exit note called focus. This idea was suggested by  Kasyanov in V. N. Kas'janov. Distinguishing hammocks in a directed graph. Soviet Math. Doklady, 16(5):448--450, 1975. ; Kasyanov's decomposition algorithm was weak and later he completely lost track of his own idea. Essentially the same idea was independendently reinvented by Gordon Oulsnam who proposed the first practically usable decomposition algorithm based of direct and reverse dominators (Oulsnam work was received in August 1984, but published in 1987).  Later Oulsnam applied this decomposition to complexity metric of the program.  Unfortunately I lost my copy of his papers.

The idea of prime hammocks or control quants.  Control quant is non-decomposable subgraph of the graph of the program with just one entry and one exit node. That means that all control quants are hammocks but not vise versa.  control quants can be also called "prime control structures" to use the analogy with prime numbers.   This idea was invented by R.A. Maddux in his  Ph.D. dissertation "Study of Program Structure, University of Waterloo (July 1975). Note that this was the same year Kas'janov paper was published. Maddux called his control structures "prime programs."

Similar approach was independently reinvented myself much later (I was not aware about his work, but was aware about Kasyanov's and Oulsnam works.  I called such structures "prime hammocks" or control quants, as they are not further decomposable into simpler structures. See

Nikolai  Bezroukov. “Quantum Decomposition of Program Schemata on Prime Hammocks”, Software Maintenance for Real Time Software Systems Based on Micro and Mini Computers. [in Russian] Kiev Institute of Civil Aviation Engineers.  Kiev (1988),  pp. 3-17.

The short summary of  Maddux work and enumeration of control quants can be found in Terrence W Pratt and Marvin V. Zelkowitz book "Programming languages: design and implementation".

The problem with this approach is that multilevel jumps (exception handling)  strongly affect program decomposition. This can be mitigated by the "normalization" of program graph before decomposition or by  minimization of the number of components (backtracking based) approaches.

I created a pilot system used for the analyses of air traffic control programs based ont his approach but my grant ended before I managed to get practically important results and later I switched to the malware analysis and disassembly and never returned to this topic.

 Top Visited

Your browser does not support iframes.

Switchboard Latest Past week Past month

## Old News ;-)

#### [Sep 06, 2019] Using Case Insensitive Matches with Bash Case Statements by Steven Vona

###### Jun 30, 2019 | www.putorius.net

If you want to match the pattern regardless of it's case (Capital letters or lowercase letters) you can set the nocasematch shell option with the shopt builtin. You can do this as the first line of your script. Since the script will run in a subshell it won't effect your normal environment.

```#!/bin/bash
shopt -s nocasematch
read -p "Name a Star Trek character: " CHAR
case \$CHAR in
"Seven of Nine" | Neelix | Chokotay | Tuvok | Janeway )
echo "\$CHAR was in Star Trek Voyager"
;;&
Archer | Phlox | Tpol | Tucker )
echo "\$CHAR was in Star Trek Enterprise"
;;&
Odo | Sisko | Dax | Worf | Quark )
echo "\$CHAR was in Star Trek Deep Space Nine"
;;&
Worf | Data | Riker | Picard )
echo "\$CHAR was in Star Trek The Next Generation" &&  echo "/etc/redhat-release"
;;
*) echo "\$CHAR is not in this script."
;;
esac
```

#### [Sep 02, 2019] Switch statement for bash script

###### Sep 02, 2019 | www.linuxquestions.org
 Switch statement for bash script [ Log in to get rid of this advertisement] Hello, i am currently trying out the switch statement using bash script. CODE: showmenu () { echo "1. Number1" echo "2. Number2" echo "3. Number3" echo "4. All" echo "5. Quit" } while true do showmenu read choice echo "Enter a choice:" case "\$choice" in "1") echo "Number One" ;; "2") echo "Number Two" ;; "3") echo "Number Three" ;; "4") echo "Number One, Two, Three" ;; "5") echo "Program Exited" exit 0 ;; *) echo "Please enter number ONLY ranging from 1-5!" ;; esac done OUTPUT: 1. Number1 2. Number2 3. Number3 4. All 5. Quit Enter a choice: So, when the code is run, a menu with option 1-5 will be shown, then the user will be asked to enter a choice and finally an output is shown. But it is possible if the user want to enter multiple choices. For example, user enter choice "1" and "3", so the output will be "Number One" and "Number Three". Any idea?
 Just something to get you started. Code: ```#! /bin/bash showmenu () { typeset ii typeset -i jj=1 typeset -i kk typeset -i valid=0 # valid=1 if input is good while (( ! valid )) do for ii in "\${options[@]}" do echo "\$jj) \$ii" let jj++ done read -e -p 'Select a list of actions : ' -a answer jj=0 valid=1 for kk in "\${answer[@]}" do if (( kk < 1 || kk > "\${#options[@]}" )) then echo "Error Item \$jj is out of bounds" 1>&2 valid=0 break fi let jj++ done done } typeset -r c1=Number1 typeset -r c2=Number2 typeset -r c3=Number3 typeset -r c4=All typeset -r c5=Quit typeset -ra options=(\$c1 \$c2 \$c3 \$c4 \$c5) typeset -a answer typeset -i kk while true do showmenu for kk in "\${answer[@]}" do case \$kk in 1) echo 'Number One' ;; 2) echo 'Number Two' ;; 3) echo 'Number Three' ;; 4) echo 'Number One, Two, Three' ;; 5) echo 'Program Exit' exit 0 ;; esac done done ```
 stevenworr View Public Profile View LQ Blog View Review Entries View HCL Entries Find More Posts by stevenworr
 11-16-2009, 10:10 PM # 4 wjs1990 Member Registered: Nov 2009 Posts: 30 Original Poster Rep: Ok will try it out first. Thanks. Last edited by wjs1990; 11-16-2009 at 10:13 PM .
 wjs1990 View Public Profile View LQ Blog View Review Entries View HCL Entries Find More Posts by wjs1990
 11-16-2009, 10:16 PM # 5 evo2 LQ Guru Registered: Jan 2009 Location: Japan Distribution: Mostly Debian and CentOS Posts: 5,945 Rep: This can be done just by wrapping your case block in a for loop and changing one line. Code: ```#!/bin/bash showmenu () { echo "1. Number1" echo "2. Number2" echo "3. Number3" echo "4. All" echo "5. Quit" } while true ; do showmenu read choices for choice in \$choices ; do case "\$choice" in 1) echo "Number One" ;; 2) echo "Number Two" ;; 3) echo "Number Three" ;; 4) echo "Numbers One, two, three" ;; 5) echo "Exit" exit 0 ;; *) echo "Please enter number ONLY ranging from 1-5!" ;; esac done done ```You can now enter any number of numbers seperated by white space. Cheers, EVo2.

#### [Dec 06, 2015] Bash For Loop Examples

##### A very nice tutorial by Vivek Gite (created October 31, 2008 last updated June 24, 2015). His mistake is putting new for loop too far inside the tutorial. It should emphazied, not hidden.
###### June 24, 2015 | cyberciti.biz

... ... ...

Bash v4.0+ has inbuilt support for setting up a step value using {START..END..INCREMENT} syntax:

```#!/bin/bash
echo "Bash version \${BASH_VERSION}..."
for i in {0..10..2}
do
echo "Welcome \$i times"
done```

Sample outputs:

```Bash version 4.0.33(0)-release...
Welcome 0 times
Welcome 2 times
Welcome 4 times
Welcome 6 times
Welcome 8 times
Welcome 10 times```

... ... ...

Three-expression bash for loops syntax

This type of for loop share a common heritage with the C programming language. It is characterized by a three-parameter loop control expression; consisting of an initializer (EXP1), a loop-test or condition (EXP2), and a counting expression (EXP3).

```for (( EXP1; EXP2; EXP3 ))
do
command1
command2
command3
done```

A representative three-expression example in bash as follows:

```#!/bin/bash
for (( c=1; c<=5; c++ ))
do
echo "Welcome \$c times"
done```
... ... ...

Jadu Saikia, November 2, 2008, 3:37 pm

Nice one. All the examples are explained well, thanks Vivek.

seq 1 2 20
output can also be produced using jot

jot – 1 20 2

The infinite loops as everyone knows have the following alternatives.

while(true)
or
while :

Andi Reinbrech, November 18, 2010, 7:42 pm
I know this is an ancient thread, but thought this trick might be helpful to someone:

For the above example with all the cuts, simply do

`set `echo \$line``

This will split line into positional parameters and you can after the set simply say

`F1=\$1; F2=\$2; F3=\$3`

I used this a lot many years ago on solaris with "set `date`", it neatly splits the whole date string into variables and saves lots of messy cutting :-)

… no, you can't change the FS, if it's not space, you can't use this method

Peko, July 16, 2009, 6:11 pm
Hi Vivek,
Thanks for this a useful topic.

IMNSHO, there may be something to modify here
=======================
Latest bash version 3.0+ has inbuilt support for setting up a step value:

#!/bin/bash
for i in {1..5}
=======================
1) The increment feature seems to belong to the version 4 of bash.
Reference: http://bash-hackers.org/wiki/doku.php/syntax/expansion/brace
Accordingly, my bash v3.2 does not include this feature.

BTW, where did you read that it was 3.0+ ?
(I ask because you may know some good website of interest on the subject).

2) The syntax is {from..to..step} where from, to, step are 3 integers.
You code is missing the increment.

Note that GNU Bash documentation may be bugged at this time,
because on GNU Bash manual, you will find the syntax {x..y[incr]}
which may be a typo. (missing the second ".." between y and increment).

The Bash Hackers page
again, see http://bash-hackers.org/wiki/doku.php/syntax/expansion/brace
seeems to be more accurate,
but who knows ? Anyway, at least one of them may be right… ;-)

Keep on the good work of your own,
Thanks a million.

- Peko

Michal Kaut July 22, 2009, 6:12 am
Hello,

is there a simple way to control the number formatting? I use several computers, some of which have non-US settings with comma as a decimal point. This means that
`for x in \$(seq 0 0.1 1)` gives 0 0.1 0.2 … 1 one some machines and 0 0,1 0,2 … 1 on other.
Is there a way to force the first variant, regardless of the language settings? Can I, for example, set the keyboard to US inside the script? Or perhaps some alternative to `\$x` that would convert commas to points?
(I am sending these as parameters to another code and it won't accept numbers with commas…)

The best thing I could think of is adding `x=`echo \$x | sed s/,/./`` as a first line inside the loop, but there should be a better solution? (Interestingly, the sed command does not seem to be upset by me rewriting its variable.)

Thanks,
Michal

Peko July 22, 2009, 7:27 am

To Michal Kaut:

Hi Michal,

Such output format is configured through LOCALE settings.

I tried :

export LC_CTYPE="en_EN.UTF-8″; seq 0 0.1 1

and it works as desired.

You just have to find the exact value for LC_CTYPE that fits to your systems and your needs.

Peko

Peko July 22, 2009, 2:29 pm

To Michal Kaus [2]

Ooops – ;-)
LC_NUMERIC should be more appropriate
(Although LC_CTYPE is actually yielding to the same result – I tested both)

By the way, Vivek has already documented the matter : http://www.cyberciti.biz/tips/linux-find-supportable-character-sets.html

Philippe Petrinko October 30, 2009, 8:35 am

To Vivek:
Regarding your last example, that is : running a loop through arguments given to the script on the command line, there is a simplier way of doing this:
# FILES="\$@"
# for f in \$FILES

# use the following syntax
for arg
do
# whatever you need here – try : echo "\$arg"
done

Of course, you can use any variable name, not only "arg".

Philippe Petrinko November 11, 2009, 11:25 am

To tdurden:

Why would'nt you use

1) either a [for] loop
for old in * ; do mv \${old} \${old}.new; done

2) Either the [rename] command ?
excerpt form "man rename" :

RENAME(1) Perl Programmers Reference Guide RENAME(1)

NAME
rename – renames multiple files

SYNOPSIS
rename [ -v ] [ -n ] [ -f ] perlexpr [ files ]

DESCRIPTION
"rename" renames the filenames supplied according to the rule specified
as the first argument. The perlexpr argument is a Perl expression
which is expected to modify the \$_ string in Perl for at least some of
the filenames specified. If a given filename is not modified by the
expression, it will not be renamed. If no filenames are given on the
command line, filenames will be read via standard input.

For example, to rename all files matching "*.bak" to strip the
extension, you might say

rename 's/\.bak\$//' *.bak

To translate uppercase names to lower, you'd use

rename 'y/A-Z/a-z/' *

- Philippe

Philippe Petrinko November 11, 2009, 9:27 pm

If you set the shell option extglob, Bash understands some more powerful patterns. Here, a is one or more pattern, separated by the pipe-symbol (|).

?() Matches zero or one occurrence of the given patterns
*() Matches zero or more occurrences of the given patterns
+() Matches one or more occurrences of the given patterns
@() Matches one of the given patterns
!() Matches anything except one of the given patterns

Philippe Petrinko November 12, 2009, 3:44 pm

To Sean:
Right, the more sharp a knife is, the easier it can cut your fingers…

I mean: There are side-effects to the use of file globbing (like in [ for f in * ] ) , when the globbing expression matches nothing: the globbing expression is not susbtitued.

Then you might want to consider using [ nullglob ] shell extension,
to prevent this.
see: http://www.bash-hackers.org/wiki/doku.php/syntax/expansion/globs#customization

Devil hides in detail ;-)

Dominic January 14, 2010, 10:04 am

There is an interesting difference between the exit value for two different for looping structures (hope this comes out right):
```for (( c=1; c<=2; c++ )) do echo -n "inside (( )) loop c is \$c, "; done; echo "done (( )) loop c is \$c" for c in {1..2}; do echo -n "inside { } loop c is \$c, "; done; echo "done { } loop c is \$c"```
You see that the first structure does a final increment of c, the second does not. The first is more useful IMO because if you have a conditional break in the for loop, then you can subsequently test the value of \$c to see if the for loop was broken or not; with the second structure you can't know whether the loop was broken on the last iteration or continued to completion.

Dominic January 14, 2010, 10:09 am

sorry, my previous post would have been clearer if I had shown the output of my code snippet, which is:
```inside (( )) loop c is 1, inside (( )) loop c is 2, done (( )) loop c is 3 inside { } loop c is 1, inside { } loop c is 2, done { } loop c is 2```

Philippe Petrinko March 9, 2010, 2:34 pm

@Dmitry

And, again, as stated many times up there, using [seq] is counter productive, because it requires a call to an external program, when you should Keep It Short and Simple, using only bash internals functions:

``` for ((c=1; c<21; c+=2)); do echo "Welcome \$c times" ; done ```

(and I wonder why Vivek is sticking to that old solution which should be presented only for historical reasons when there was no way of using bash internals.
By the way, this historical recall should be placed only at topic end, and not on top of the topic, which makes newbies sticking to the not-up-to-date technique ;-) )

Sean March 9, 2010, 11:15 pm

I have a comment to add about using the builtin for (( … )) syntax. I would agree the builtin method is cleaner, but from what I've noticed with other builtin functionality, I had to check the speed advantage for myself. I wrote the following files:

builtin_count.sh:
``` #!/bin/bash for ((i=1;i<=1000000;i++)) do echo "Output \$i" done ```

seq_count.sh:
``` #!/bin/bash for i in \$(seq 1 1000000) do echo "Output \$i" done ```

And here were the results that I got:
time ./builtin_count.sh
real 0m22.122s
user 0m18.329s
sys 0m3.166s

time ./seq_count.sh
real 0m19.590s
user 0m15.326s
sys 0m2.503s

The performance increase isn't too significant, especially when you are probably going to be doing something a little more interesting inside of the for loop, but it does show that builtin commands are not necessarily faster.

Andi Reinbrech November 18, 2010, 8:35 pm

The reason why the external seq is faster, is because it is executed only once, and returns a huge splurb of space separated integers which need no further processing, apart from the for loop advancing to the next one for the variable substitution.

The internal loop is a nice and clean/readable construct, but it has a lot of overhead. The check expression is re-evaluated on every iteration, and a variable on the interpreter's heap gets incremented, possibly checked for overflow etc. etc.

Note that the check expression cannot be simplified or internally optimised by the interpreter because the value may change inside the loop's body (yes, there are cases where you'd want to do this, however rare and stupid they may seem), hence the variables are volatile and get re-evaluted.

I.e. botom line, the internal one has more overhead, the "seq" version is equivalent to either having 1000000 integers inside the script (hard coded), or reading once from a text file with 1000000 integers with a cat. Point being that it gets executed only once and becomes static.

OK, blah blah fishpaste, past my bed time :-)

Cheers,
Andi

Anthony Thyssen June 4, 2010, 6:53 am

The {1..10} syntax is pretty useful as you can use a variable with it!

```limit=10
echo {1..\${limit}}
{1..10}```

You need to eval it to get it to work!

```limit=10
eval "echo {1..\${limit}}"
1 2 3 4 5 6 7 8 9 10
```

'seq' is not avilable on ALL system (MacOSX for example)
and BASH is not available on all systems either.

You are better off either using the old while-expr method for computer compatiblity!

```   limit=10; n=1;
while [ \$n -le 10 ]; do
echo \$n;
n=`expr \$n + 1`;
done
```

Alternativally use a seq() function replacement…

``` # seq_count 10
seq_count() {
i=1; while [ \$i -le \$1 ]; do echo \$i; i=`expr \$i + 1`; done
}
# simple_seq 1 2 10
simple_seq() {
i=\$1; while [ \$i -le \$3 ]; do echo \$i; i=`expr \$i + \$2`; done
}
seq_integer() {
if [ "X\$1" = "X-f" ]
then format="\$2"; shift; shift
else format="%d"
fi
case \$# in
1) i=1 inc=1 end=\$1 ;;
2) i=\$1 inc=1 end=\$2 ;;
*) i=\$1 inc=\$2 end=\$3 ;;
esac
while [ \$i -le \$end ]; do
printf "\$format\n" \$i;
i=`expr \$i + \$inc`;
done
}
```

TheBonsai June 4, 2010, 9:57 am

The Bash C-style for loop was taken from KSH93, thus I guess it's at least portable towards Korn and Z.

The seq-function above could use i=\$((i + inc)), if only POSIX matters. expr is obsolete for those things, even in POSIX.

Philippe Petrinko June 4, 2010, 10:15 am

But FOR C-style does not seem to be POSIXLY-correct…

Top is here, http://www.opengroup.org/onlinepubs/009695399/mindex.html

and the Shell and Utilities volume (XCU) T.OC. is here
http://www.opengroup.org/onlinepubs/009695399/utilities/toc.html
doc is:
http://www.opengroup.org/onlinepubs/009695399/basedefs/xbd_chap01.html

Anthony Thyssen June 6, 2010, 7:18 am

TheBonsai wrote…. "The seq-function above could use i=\$((i + inc)), if only POSIX matters. expr is obsolete for those things, even in POSIX."

I am not certain it is in Posix. It was NOT part of the original Bourne Shell, and on some machines, I deal with Bourne Shell. Not Ksh, Bash, or anything else.

Bourne Shell syntax works everywhere! But as 'expr' is a builtin in more modern shells, then it is not a big loss or slow down.

This is especially important if writing a replacement command, such as for "seq" where you want your "just-paste-it-in" function to work as widely as possible.

I have been shell programming pretty well all the time since 1988, so I know what I am talking about! Believe me.

MacOSX has in this regard been the worse, and a very big backward step in UNIX compatibility. 2 year after it came out, its shell still did not even understand most of the normal 'test' functions. A major pain to write shells scripts that need to also work on this system.

TheBonsai June 6, 2010, 12:35 pm

Yea, the question was if it's POSIX, not if it's 100% portable (which is a difference). The POSIX base more or less is a subset of the Korn features (88, 93), pure Bourne is something "else", I know. Real portability, which means a program can go wherever UNIX went, only in C ;)

Philippe Petrinko November 22, 2010, 8:23 am

And if you want to get rid of double-quotes, use:

one-liner code:
```while read; do record=\${REPLY}; echo \${record}|while read -d ","; do field="\${REPLY#\"}"; field="\${field%\"}"; echo \${field}; done; done<data ```

script code, added of some text to better see record and field breakdown:
``` #!/bin/bash while read do echo "New record" record=\${REPLY} echo \${record}|while read -d , do field="\${REPLY#\"}" field="\${field%\"}" echo "Field is :\${field}:" done done<data ```

Does it work with your data?

- PP

Philippe Petrinko November 22, 2010, 9:01 am

Of course, all the above code was assuming that your CSV file is named "data".

If you want to use anyname with the script, replace:
``` done<data ```
With:
``` done ```

And then use your script file (named for instance "myScript") with standard input redirection:
``` myScript < anyFileNameYouWant ```

Enjoy!

Philippe Petrinko November 22, 2010, 11:28 am

well no there is a bug, last field of each record is not read – it needs a workout and may be IFS modification ! After all that's what it was built for… :O)

Anthony Thyssen November 22, 2010, 11:31 pm

Another bug is the inner loop is a pipeline, so you can't assign variables for use later in the script. but you can use '<<<' to break the pipeline and avoid the echo.

But this does not help when you have commas within the quotes! Which is why you needed quotes in the first place.

In any case It is a little off topic. Perhaps a new thread for reading CVS files in shell should be created.

Philippe Petrinko November 24, 2010, 6:29 pm

Anthony,
Would you try this one-liner script on your CSV file?

This one-liner assumes that CSV file named [data] has __every__ field double-quoted.

``` while read; do r="\${REPLY#\"}";echo "\${r//\",\"/\"}"|while read -d \";do echo "Field is :\${REPLY}:";done;done<data ```

Here is the same code, but for a script file, not a one-liner tweak.

``` #!/bin/bash # script csv01.sh # # 1) Usage # This script reads from standard input # any CSV with double-quoted data fields # and breaks down each field on standard output # # 2) Within each record (line), _every_ field MUST: # - Be surrounded by double quotes, # - and be separated from preceeding field by a comma # (not the first field of course, no comma before the first field) # while read do echo "New record" # this is not mandatory-just for explanation # # # store REPLY and remove opening double quote record="\${REPLY#\"}" # # # replace every "," by a single double quote record=\${record//\",\"/\"} # # echo \${record}|while read -d \" do # store REPLY into variable "field" field="\${REPLY}" # # echo "Field is :\${field}:" # just for explanation done done ```

This script named here [cvs01.sh] must be used so:
``` cvs01.sh < my-cvs-file-with-doublequotes ```

Philippe Petrinko November 24, 2010, 6:35 pm

@Anthony,

By the way, using [REPLY] in the outer loop _and_ the inner loop is not a bug.
As long as you know what you do, this is not problem, you just have to store [REPLY] value conveniently, as this script shows.

TheBonsai March 8, 2011, 6:26 am
`for ((i=1; i<=20; i++)); do printf "%02d\n" "\$i"; done`

nixCraft March 8, 2011, 6:37 am

+1 for printf due to portability, but you can use bashy .. syntax too

`for i in {01..20}; do echo "\$i"; done`

TheBonsai March 8, 2011, 6:48 am

Well, it isn't portable per se, it makes it portable to pre-4 Bash versions.

I think a more or less "portable" (in terms of POSIX, at least) code would be

```i=0
while [ "\$((i >= 20))" -eq 0 ]; do
printf "%02d\n" "\$i"
i=\$((i+1))
done```

Philip Ratzsch April 20, 2011, 5:53 am

I didn't see this in the article or any of the comments so I thought I'd share. While this is a contrived example, I find that nesting two groups can help squeeze a two-liner (once for each range) into a one-liner:

for num in {{1..10},{15..20}};do echo \$num;done

Great reference article!

Philippe Petrinko April 20, 2011, 8:23 am

@Philip
Nice thing to think of, using brace nesting, thanks for sharing.

Philippe Petrinko May 6, 2011, 10:13 am

Hello Sanya,

That would be because brace expansion does not support variables. I have to check this.
Anyway, Keep It Short and Simple: (KISS) here is a simple solution I already gave above:

xstart=1;xend=10;xstep=1
for (( x = \$xstart; x <= \$xend; x += \$xstep)); do echo \$x;done

Actually, POSIX compliance allows to forget \$ in for quotes, as said before, you could also write:

xstart=1;xend=10;xstep=1
for (( x = xstart; x <= xend; x += xstep)); do echo \$x;done

Philippe Petrinko May 6, 2011, 10:48 am

Sanya,

Actually brace expansion happens __before__ \$ parameter exapansion, so you cannot use it this way.

Nevertheless, you could overcome this this way:

max=10; for i in \$(eval echo {1..\$max}); do echo \$i; done

Sanya May 6, 2011, 11:42 am

Hello, Philippe

You basically confirmed my findings, that bash constructions are not as simple as zsh ones.
But since I don't care about POSIX compliance, and want to keep my scripts "readable" for less experienced people, I would prefer to stick to zsh where my simple for-loop works

Cheers, Sanya

Philippe Petrinko May 6, 2011, 12:07 pm

Sanya,

First, you got it wrong: solutions I gave are not related to POSIX, I just pointed out that POSIX allows not to use \$ in for (( )), which is just a little bit more readable – sort of.

Second, why do you see this less readable than your [zsh] [for loop]?

for (( x = start; x <= end; x += step)) do
echo "Loop number \${x}"
done

It is clear that it is a loop, loop increments and limits are clear.

IMNSHO, if anyone cannot read this right, he should not be allowed to code. :-D

BFN

Anthony Thyssen May 8, 2011, 11:30 pm

If you are going to do… \$(eval echo {1..\$max});
You may as well use "seq" or one of the many other forms.
See all the other comments on doing for loops.

Tom P May 19, 2011, 12:16 pm

I am trying to use the variable I set in the for line on to set another variable with a different extension. Couldn't get this to work and couldnt find it anywhere on the web… Can someone help.

Example:

```FILE_TOKEN=`cat /tmp/All_Tokens.txt`
for token in \$FILE_TOKEN
do
A1_\$token=`grep \$A1_token /file/path/file.txt | cut -d ":" -f2`
```

my goal is to take the values from the ALL Tokens file and set a new variable with A1_ infront of it… This tells be that A1_ is not a command…

#### [Jun 06, 2011] Measuring Prime Program Complexity by MARVIN V. ZELKOWITZ & JIANHUI TIAN

###### Jan 1, 1994 | University of Maryland

This paper uses the prime program decomposition of a program as the basis for a measure that closely correlates with our intuitive notion of program complexity. This measure is based upon the information theory ideas of randomness and entropy such that results about structured programming, data abstractions, and other programming paradigms can be stated in quantitative terms, and empirical means can be used to validate the assumptions used to develop the model.

As a graph-based model, it can be applied to several graphical examples as extensions not otherwise available to sourcecode based models. This paper introduces the measure, derives several properties for it, and gives some simple examples to demonstrate that the measure is a plausible approximation of our notions concerning structured programming.

#### [Jun 06, 2011] Global data flow analysis by decomposition into primes

Global data flow analysis by decomposition into primes

Ira R. Forman ICSE '82 Proceedings of the 6th international conference on Software engineering IEEE Computer Society Press Los Alamitos, CA, USA

Cognitive Design Elements to Support the Construction of .. - Storey, Fracchia, Müller (1999) (11 citations)
observed that programmers first develop a control-flow abstraction of the program which captures the www.csr.uvic.ca/~mstorey/papers/jss.ps

Understanding Function Behaviors through Program Slicing - De Lucia, Fasolino, Munro (1996) (4 citations)
of the program she builds is a control-flow abstraction called the program model. The program
orca.unl.ac.uk/~mark/delucia.ps

From Program Comprehension to Tool Requirements for an.. - von Mayrhauser, Vans (1993) (Correct) (2 citations)
representation programmers build is a control flow abstraction of the program called the program
www.cs.colostate.edu/~aaa/cmp2.ps

Comprehension Processes During Large Scale Maintenance - von Mayrhauser, Vans (1994) (Correct) (1 citation)
build is a program model consisting of a control flow abstraction of the program [5]Suppose an engineer
www.cs.colostate.edu/~aaa/icse.ps

From Code Understanding Needs to Reverse Engineering Tool.. - von Mayrhauser, Vans (1993) (Correct)
representation programmers build is a control flow abstraction of the program called the program
www.cs.colostate.edu/~aaa/case93.ps

Program Comprehension And Enhancement Of Software - von Mayrhauser, Vans, Lang (Correct)
6] found that programmers first build a control flow abstraction of the program called the program
www.cs.colostate.edu/~aaa/ifip.ps

Control Abstraction in Parallel Programming Languages - Lawrence Crowl Department (1992) (Correct)
that parallelism is a form of control flow, control abstraction is particularly important for parallel
www.crowl.org/Lawrence/paper/conferences/1992P-ICCL-44/fulltext.ps.gz

Identifying Procedural Structure in Cobol Programs - John Field Ramalingam (Correct)
Abstract The principal control-flow abstraction mechanism in the Cobol language is the
www.research.ibm.com/people/r/rama/Papers/paste99.ps

Replicable GMBs: A tool for the specification of.. - Mar'ia Cecilia (Correct)
layer, but do little to help create the dialog control layer, let alone to provide semantic feedback.
at just two levels of abstraction: control flow, specified with GMB, and operations, specified in
Structure is specified at several levels of abstraction, by nesting boxes, as in Structured Boxes

ftp.ing.puc.cl/pub/escuela/dcc/techReports/rt94-03.ps

VASE User's Manual Version 1.0 - David Jablonowski (Correct)
steering applications. vase uses a control-flow abstraction to describe the complex internal
www.csrd.uiuc.edu/reports/1294.ps.gz

Congestion Control in BBN Packet-Switched Networks* - John Robinson Dan (Correct)
result in instabilities, when delay is used to control flow rates. 3. It is difficult to design a fair
its submission rate. The use of window-based flow control protocols at the higher level will
reasons: 1. There may be no window-oriented flow control in use for some of the congesting traffic. 2.

gatekeeper.dec.com/pub/doc/sigcomm/ccr/archive/1990/jan90/robinson.ps.Z

LISP AND SYMBOLIC COMPUTATION: An International Journal, .. - Callee-Save Registers In (Correct)
to A-calculus, but which closely reflects the control-flow and data-flow operations of a yon Neumann
ftp.cs.princeton.edu/pub/packages/ml/zsh/callee.ps

Programming the Hawaii Parallel Computer - Richard Halverson Jr (Correct)
traditional language constructs for defining control flow. One way to use the XILINX board on a HPC
ftp.ics.Hawaii.Edu/pub/tr/ics-tr-94-24.ps.Z

Rule Based Specification of Information Systems - Peter Mcbrien And (Correct)
and costly due to the difference between control flow and data flow not having been modelled in
argon.dcs.kcl.ac.uk/staff/pjm/publications/MSW94.ps.gz

March 1995 - Flight Safety Digest (Correct)
airports Airspace capacity bottlenecks Flow control and the competition for slot times and,
www.flightsafety.org/fsd/fsd_mar95.pdf

Progressive Profiling: A Methodology based on - Profile Propagation And (Correct)
for exact matches based on each procedure's control flow structure, and propagates the entire profile
or additional information from the compiler. 3 Control Flow-based Binary Matching This section describes

www.cesr.ncsu.edu/fddo4/papers/FDDO_ZhengWang.pdf

Unknown - (Correct)
the tightcoupling between wormhole routers for flow control to detect and recover from potential dead-
The basic idea is to use the fine-grained flow control and backpressure of wormhole routing to
The CR routing mechanisms provide end-to-end flow control and fault tolerance that obviates the need for

csag.ucsd.edu/papers/cr-tpds.ps

A Backward Error Recovery Scheme for the - Apemille Parallel Computer (Correct)
unit (called Tmille) performing mainly flow- control, signal handling, and global integer
www.inf.mit.bme.hu/FTSRG/Publications/EWDC-11b.pdf

Graph-Based Models for Managing Development Processes.. - Carl-Arndt Krapp Sven (Correct)
relationships, tasks are connected by control flows (similar to precedence relationships in net
and for testing are inserted into the task net. Control flow dependencies are established between the

www-i3.informatik.rwth-aachen.de/private/schleicher/tagt98.ps

Why Computer Interfaces Are Not Like Paintings: - The User As (Correct)
language is usually based on either a control flow or a data flow model. Graphical interface: a
hwr.nici.kun.nl/cognavhyp/Petre-notPainting-EWHCI92.ps

Congestion Control in Routing Networks - Chien (1986) (Correct)
Problem .49 4.2 Flow Control in Data Networks .50
64 5.3.1 System Performance without Flow Control .64 5.3.2 System Performance
.64 5.3.2 System Performance with Flow Control .69 5.4 Overall System

www.lcs.mit.edu/publications/pubs/pdf/MIT-LCS-TR-382.pdf

IP switching in a simplified ATM environment - Mika Ilvesmki Marko (Correct)
Internet traffic has the ability to handle the flow control on connection basis and that no additional
on connection basis and that no additional flow control is needed. Amount of congestion Received

keskus.hut.fi/~mluoma/publications/vvdc97co.ps

Flip-Tick Architecture: a cycle-oriented architecture - For Distributed Problem (Correct)
events. The cycles are not based on an explicit control flow management that takes care of timely operation
only way of exchanging data between actors, the control flow results from three intertwined mechanisms: i)

set.gmd.de/pub/SET/publications/released/1998/pdf/Richter98.1.pdf

Application Performance of a Linux Cluster - Using Converse Laxmikant (Correct)
is not guaranteed, we implement a window-based flow-control protocol. To deal with the fact that there are
www.ks.uiuc.edu/~brunner/Papers/RTSPP99.ps

Towards Maximising the use of Structural VHDL for Synthesis - O'Brien, Robert, Maginot (Correct)
but only in specific areas such as describing control flow and synchronisation. In the rest of this
herkules.informatik.tu-chemnitz.de/proceedings/eurodac-96/papers/1996/eurdac96/htmfiles/sun_sgi/../../pdffiles/v07_3.pdf

Light Weight Optimizations for Reducing Hot Saves and.. - Of Callee-Saved Registers (Correct)
according to their liveness in the call and control flow graphs of the program This method requires a
accomplish this, they also make use of data and control flow analyses. Others [4, 8, 9, 10, 16] handle the

www.cesr.ncsu.edu/fddo4/papers/bilha.pdf

Primitive Geometric Operations on - Planar Algebraic Curves (Correct)
sufficient precisions to direct the algorithm control flows correctly. These primitive geometric
and efficiency dynamically depending on the control flow of algorithm, i.e.use low precision

3map.snu.ac.kr/mskim/ftp/gauss93.ps

Henry Chang - Top-Down Constraint-Driven Design (Correct)
criteria set by the mapping function, then the flow control is returned to the mapping function. On a
As before, if this step fails, the flow control is returned to the mapping function. If it is
If all of the specifications are met, the flow control is returned to the upper node with the

ic.eecs.berkeley.edu/pub/Papers_Talks/Analog_Group/PostScript/CICC92_chang.ps.Z

Demonstration of an Automated Integrated Test.. - Margaria, Niese, Steffen (2001) (Correct)
correctness and consistency of the test cases' control flow logic [3]During the test case design, vital
ls5-www.cs.uni-dortmund.de/~niese/Niese02c.pdf

Unification of Finite Failure Non-Homogeneous Poisson - Process Models Through (Correct)
types of coverage definitions in literature: control-flow and data-flow coverage[2, 6, 7, 16]Each
on the Effectiveness of Dataflow-and Control-flowbased Test Adequacy Criteria,Proc. of Intl.

www.ee.duke.edu/~ssg/softrel/TechReports/issre.ps.gz

Terrence Pratt

• Richard J. Lipton and David Dobkin. Complexity measures and hierarchies for the evaluation of integers, polynomials, and n-linear forms. In Conference Record of Seventh Annual ACM Symposium on Theory of Computation, pages 1-5, Albuquerque, New Mexico, 5-7 May 1975. [BibTeX entry]

• Ronald L. Rivest and Jean Vuillemin. A generalization and proof of the Aanderaa-Rosenberg conjecture. In Conference Record of Seventh Annual ACM Symposium on Theory of Computation, pages 6-11, Albuquerque, New Mexico, 5-7 May 1975. [BibTeX entry]

• L. Hyafil and H. T. Kung. The complexity of parallel evaluation of linear recurrence. In Conference Record of Seventh Annual ACM Symposium on Theory of Computation, pages 12-22, Albuquerque, New Mexico, 5-7 May 1975. [BibTeX entry]

• Andrew Chi-Chih Yao. On computing the minima of quadratic forms (preliminary report). In Conference Record of Seventh Annual ACM Symposium on Theory of Computation, pages 23-26, Albuquerque, New Mexico, 5-7 May 1975. [BibTeX entry]

• Wolfgang J. Paul. A 2.5 n-lower bound on the combinatorial complexity of Boolean functions. In Conference Record of Seventh Annual ACM Symposium on Theory of Computation, pages 27-36, Albuquerque, New Mexico, 5-7 May 1975. Citations. [BibTeX entry]

• Michael J. Fischer, Albert R. Meyer, and Michael S. Paterson. Lower bounds on the size of Boolean formulas: Preliminary report. In Conference Record of Seventh Annual ACM Symposium on Theory of Computation, pages 37-44, Albuquerque, New Mexico, 5-7 May 1975. Citations, etc. [BibTeX entry]

• Leslie G. Valiant. On non-linear lower bounds in computational complexity. In Conference Record of Seventh Annual ACM Symposium on Theory of Computation, pages 45-53, Albuquerque, New Mexico, 5-7 May 1975. Additional information. [BibTeX entry]

• H. B. Hunt, III and T. G. Szymanski. On the complexity of grammar and related problems. In Conference Record of Seventh Annual ACM Symposium on Theory of Computation, pages 54-65, Albuquerque, New Mexico, 5-7 May 1975. Additional information. [BibTeX entry]

• Shimon Even and R. Endre Tarjan. a combinatorial problem which is complete in polynomial space. In Conference Record of Seventh Annual ACM Symposium on Theory of Computation, pages 66-71, Albuquerque, New Mexico, 5-7 May 1975. [BibTeX entry]

• Zvi Galil. On the validity and complexity of bounded resolution. In Conference Record of Seventh Annual ACM Symposium on Theory of Computation, pages 72-82, Albuquerque, New Mexico, 5-7 May 1975. [BibTeX entry]

• Stephen A. Cook. Feasibly constructive proofs and the propositional calculus (preliminary version). In Conference Record of Seventh Annual ACM Symposium on Theory of Computation, pages 83-97, Albuquerque, New Mexico, 5-7 May 1975. Citations. [BibTeX entry]

• Herbert Egli and Robert L. Constable. Computability concepts for programming language semantics. In Conference Record of Seventh Annual ACM Symposium on Theory of Computation, pages 98-106, Albuquerque, New Mexico, 5-7 May 1975. [BibTeX entry]

• Derek C. Oppen and Stephen A. Cook. Proving assertions about programs that manipulate data structures. In Conference Record of Seventh Annual ACM Symposium on Theory of Computation, pages 107-116, Albuquerque, New Mexico, 5-7 May 1975. [BibTeX entry]

• A. Ehrenfeucht and G. Rozenberg. On (un)predictability of formal languages (extended abstract). In Conference Record of Seventh Annual ACM Symposium on Theory of Computation, pages 117-120, Albuquerque, New Mexico, 5-7 May 1975. [BibTeX entry]

• Sven Skyum. On decomposing languages defined by parallel devices. In Conference Record of Seventh Annual ACM Symposium on Theory of Computation, pages 121-125, Albuquerque, New Mexico, 5-7 May 1975. [BibTeX entry]

• C. Raymond Perrault. Intercalation theorems for tree transducer languages. In Conference Record of Seventh Annual ACM Symposium on Theory of Computation, pages 126-136, Albuquerque, New Mexico, 5-7 May 1975. Additional information. [BibTeX entry]

• A. Ehrenfeucht and G. Rozenberg. On the (combinatorial) structure of L languages without interactions. In Conference Record of Seventh Annual ACM Symposium on Theory of Computation, pages 137-144, Albuquerque, New Mexico, 5-7 May 1975. [BibTeX entry]

• Detlef Wotschke. Degree-languages, polynomial time recognition, and the LBA problem. In Conference Record of Seventh Annual ACM Symposium on Theory of Computation, pages 145-152, Albuquerque, New Mexico, 5-7 May 1975. Additional information. [BibTeX entry]

• Seymour Ginsburg and Nancy Lynch. Comparative complexity of grammar forms. In Conference Record of Seventh Annual ACM Symposium on Theory of Computation, pages 153-158, Albuquerque, New Mexico, 5-7 May 1975. [BibTeX entry]

• Arnold L. Rosenberg and Larry J. Stockmeyer. Hashing schemes for extendible arrays (extended arrays). In Conference Record of Seventh Annual ACM Symposium on Theory of Computation, pages 159-166, Albuquerque, New Mexico, 5-7 May 1975. [BibTeX entry]

• Terrence Pratt. Four models for the analysis of optimization of program control structures. In Conference Record of Seventh Annual ACM Symposium on Theory of Computation, pages 167-176, Albuquerque, New Mexico, 5-7 May 1975. [BibTeX entry]

• A. V. Aho and J. D. Ullman. Node listings for reducible flow graphs. In Conference Record of Seventh Annual ACM Symposium on Theory of Computation, pages 177-185, Albuquerque, New Mexico, 5-7 May 1975. Additional information. [BibTeX entry]

• R. J. Lipton, S. C. Eisenstat, and R. A. DeMillo. The complexity of control structures and data structures. In Conference Record of Seventh Annual ACM Symposium on Theory of Computation, pages 186-193, Albuquerque, New Mexico, 5-7 May 1975. [BibTeX entry]

• Zohar Manna and Adi Shamir. The optimal fixedpoint of recursive programs. In Conference Record of Seventh Annual ACM Symposium on Theory of Computation, pages 194-206, Albuquerque, New Mexico, 5-7 May 1975. [BibTeX entry]

• A. V. Aho and S. C. Johnson. Optimal code generation for expression trees. In Conference Record of Seventh Annual ACM Symposium on Theory of Computation, pages 207-217, Albuquerque, New Mexico, 5-7 May 1975. [BibTeX entry]

• Robert A. Wagner. On the complexity of the extended string-to-string correction problem. In Conference Record of Seventh Annual ACM Symposium on Theory of Computation, pages 218-223, Albuquerque, New Mexico, 5-7 May 1975. Citations. [BibTeX entry]

• Michael Ian Shamos. Geometric complexity. In Conference Record of Seventh Annual ACM Symposium on Theory of Computation, pages 224-233, Albuquerque, New Mexico, 5-7 May 1975. Citations. [BibTeX entry]

• Gary L. Miller. Riemann's hypothesis and tests for primality. In Conference Record of Seventh Annual ACM Symposium on Theory of Computation, pages 234-239, Albuquerque, New Mexico, 5-7 May 1975. Additional information. [BibTeX entry]

• Michael L. Fredman. Two applications of a probabilistic search technique: Sorting x + y and building balanced search trees. In Conference Record of Seventh Annual ACM Symposium on Theory of Computation, pages 240-244, Albuquerque, New Mexico, 5-7 May 1975. Citations. [BibTeX entry]

• Donald J. Rose and R. Endre Tarjan. Algorithmic aspects of vertex elimination. In Conference Record of Seventh Annual ACM Symposium on Theory of Computation, pages 245-254, Albuquerque, New Mexico, 5-7 May 1975. Citations. [BibTeX entry]

• Kellogg S. Booth and George S. Lueker. Linear algorithms to recognize interval graphs and test for the consecutive ones property. In Conference Record of Seventh Annual ACM Symposium on Theory of Computation, pages 255-265, Albuquerque, New Mexico, 5-7 May 1975. Citations, etc. [BibTeX entry]

## Etc

The Last but not Least Technology is dominated by two types of people: those who understand what they do not manage and those who manage what they do not understand ~Archibald Putt. Ph.D

Copyright © 1996-2018 by Dr. Nikolai Bezroukov. www.softpanorama.org was initially created as a service to the (now defunct) UN Sustainable Development Networking Programme (SDNP) in the author free time and without any remuneration. This document is an industrial compilation designed and created exclusively for educational use and is distributed under the Softpanorama Content License. Original materials copyright belong to respective owners. Quotes are made for educational purposes only in compliance with the fair use doctrine.

FAIR USE NOTICE This site contains copyrighted material the use of which has not always been specifically authorized by the copyright owner. We are making such material available to advance understanding of computer science, IT technology, economic, scientific, and social issues. We believe this constitutes a 'fair use' of any such copyrighted material as provided by section 107 of the US Copyright Law according to which such material can be distributed without profit exclusively for research and educational purposes.

This is a Spartan WHYFF (We Help You For Free) site written by people for whom English is not a native language. Grammar and spelling errors should be expected. The site contain some broken links as it develops like a living tree...

 You can use PayPal to make a contribution, supporting development of this site and speed up access. In case softpanorama.org is down you can use the at softpanorama.info

Disclaimer:

The statements, views and opinions presented on this web page are those of the author (or referenced source) and are not endorsed by, nor do they necessarily reflect, the opinions of the author present and former employers, SDNP or any other organization the author may be associated with. We do not warrant the correctness of the information provided or its fitness for any purpose.

The site uses AdSense so you need to be aware of Google privacy policy. You you do not want to be tracked by Google please disable Javascript for this site. This site is perfectly usable without Javascript.