1

A common way awk scripts are written is to use top-level pattern-action blocks. The file would then consist of multiple top-level pattern-action blocks. Each block would apply to input lines matching its pattern. This works well for simple operations intended for a single purpose.

I would like my awk files to have the capability of performing more than a single specific operation on the data.

Have found that to perform different operations conditionally or modularly, top-level blocks alone become unwieldy.

Using functions with a mode variable for each operation I want to perform can be used to select which function to call for each input line. Which lets me write a single main block that dispatches processing based on the mode.

function operation1(line) {
  # code for operation 1
}

function operation2(line) {
  # code for operation 2
}

{
  if (mode == "op1") {
    operation1($0)
  } else if (mode == "op2") {
    operation2($0)
  } else {
    # default action
    print $0
  }
}

I then pass the mode variable from the command line:

awk -v mode=op1 -f script.awk inputfile

Is this the way to accomplish what I want? Are there other ways that can be used?

Improve this question
0

2 Answers 2

Reset to default
2

What you have would be fine, though it's often written as:

function operation1(line) {
  # code for operation 1
}

function operation2(line) {
  # code for operation 2
}

mode == "op1" { operation1($0); next }
mode == "op2" { operation2($0); next }
{ print }     # default action

You can alternatively use indirect function calls with GNU awk to map the value of mode directly to the name of a function, e.g.:

BEGIN {
    fun = "operation" gensub(/op/,"",1,mode)
    if ( ! (fun in FUNCTAB) ) {
        fun = "operation_default"
    }
}

function operation1(line) {
  # code for operation 1
}

function operation2(line) {
  # code for operation 2
}

function operation_default(line) {
  # default action
}

{ @fun($0) }

Here's the problem with the above though - awk is a text processing tool. It's main purpose is to read input and do things given various values in the input. So when you write code like any form of:

mode == "op1" { operation1($0); next }
mode == "op2" { operation2($0); next }

it's being executed within awks implied while-read loop as:

while (read $0) {
    mode == "op1" { operation1($0); next }
    mode == "op2" { operation2($0); next }
}

so mode == "op1" is being tested for every line of the input and then the associated function operation1($0) is being called for every line of the input when you call the script with -v mode="op1". Given that, what would operation1() actually do?

In C or some other procedural language you might write the equivalent of:

if (mode == "op1") { operation1(); next }
if (mode == "op2") { operation2(); next }

and then you'd write operation1() as:

operation1() {
    while (read line) {
        do operation1 stuff
    }
}

but then the while-read loop that awk provides at the outer level is written at the lower level within each function. You can implement that in awk with a getline loop but that has caveats/issues, see http://awk.freeshell.org/AllAboutGetline.

So, while you can write functions to be called as the OP shows, their applicability tends to be quite limited given awks role as a text-processing tool doing things within a built-in while-read loop (where each mutually-exclusive function called from the highest level tends to be "do something with the current record") rather than a general purpose programming language (where each mutually-exclusive function called from the highest level tends to be "do something with the entire input").

One example of the kind of use-case for such a program structure in awk might be converting input to some other form of output one record at a time, e.g.:

function prtCsv(    i) {
    for ( i=1; i<=NF; i++ ) {
        gsub(/^"|"$/, "", $i)
        gsub(/"/, "\"\"", $i)
        printf("\"%s\"%s", $i, (i<NF ? "," : ORS)
    }
}

function prtTree(    i) {
    for ( i=1; i<=NF; i++ ) {
        print "%*s%s\n", (i-1)*4, "", $i
    }
}

mode == "csv"  { prtCsv(); next }
mode == "tree" { prtTree(); next }
{ print }     # default action
Improve this answer
1

Expanding on the comment about moving individual operation code blocks into separate awk files while generalizing the main awk script, and assuming you're using GNU awk ...

Sample data file:

$ cat dat.file
line 1
line 2
line 3

Three separate files containing different awk functions:

$ head op?.awk
==> op1.awk <==
function operation(line) {
    print "operation #1:",line
}

==> op2.awk <==
function operation(line) {
    print "It's me:",line
}

==> op3.awk <==
function operation(line) {
    print "Once upon a time ...",line
}

Notice all files are defining functions that have the same name. We could use different names for the functions but in this case we want to show how a commonly named function can be used to reduce the amount of code in the main awk script (below).

Make sure awk knows where to find our opN.awk script files:

$ export AWKPATH=.

Lastly we have our main awk script:

$ cat main.awk
{ operation($0) }

Notice no need to test for a mode of operation; we'll address the mode on the command line by providing the desired -i opN.awk clause, eg:

$ awk -i op1.awk -f main.awk file.dat
operation #1: line 1
operation #1: line 2
operation #1: line 3

Expanding the example to use a OS-level variable (mode) to use the associated opN.awk script file:

for mode in op1 op2 op3
do
    printf "\n####### mode = %s\n" "${mode}"
    awk -i "${mode}".awk -f main.awk file.dat
done

This generates:

####### mode = op1
operation #1: line 1
operation #1: line 2
operation #1: line 3

####### mode = op2
It's me: line 1
It's me: line 2
It's me: line 3

####### mode = op3
Once upon a time ... line 1
Once upon a time ... line 2
Once upon a time ... line 3
Improve this answer

You must log in to answer this question.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.