esclarecimento do corpo da função de script AWK

Question

Eu estava revisando um script e estou preso, apesar de meus esforços no Google para decifrar como essa função específica funciona.

Eu consegui o papel para gettimestamp & printeverything funciona e como é chamado. No entanto, começando com ORA até Housetype, não sei como funciona. De acordo com este AWK tutorial , existem funções predefinidas no AWK e sempre começam com a função, mas eu não conseguia ver nenhuma referência ou exemplos para o código incluído em "< --- A seção é confusa ---- >". Eu não estou pedindo para alguém explicar todo o código, mas em particular se você pode explicar pelo menos como / ^ DocType \ | / funciona seção. Por favor, veja meus comentários abaixo.

    func_sql()
    {
            ITMF=$TMF.2
            _retrieve | _run_sqlplus 2>&1 | ${_APP_AWK} -vtmf=$ITMF '

            BEGIN {
                    FS = "^B";
                    cnt=0;
                    printf("umask 007;\n") >>tmf
                    printf("cd %s;\n", imgDir) >>tmf
            }

            function getTimeStamp(s) {
                    printf("%s %s\n", strftime("[%a %b %d %H:%M:%S]"), s) >>logFile
            }

            function printEverything(s) {
                    printf("<P>%s %s\n", strftime("[%a %b %d %H:%M:%S]"), s);
                    printf("%s %s\n",
                            strftime("[%a %b %d %H:%M:%S]"),
                            s) >>logFile
            }
    <--- This section is confusing ------>
            /^ORA-.*:|^PLS-.*:|^SP2-.*/ { <-- I don't understand this part
                    getTimeStamp($0) <--- I understand this
                    printf("\nSQLBAD|1000|%s\n", $0); <--- I understand this
                    exit(1); <--- I understand this
            }

            /^ERROR/ { <-- I don't understand this part
<--Truncated-->
            }

            /\[.*\]\|Error.*/ { <-- I don't understand this part
                    <--Truncated-->
            }

            /^HouseType\|/ { <-- I don't understand this part
                    gsub("[[:space:]]+", " ");<--- I understand this
                    gsub("^[[:space:]]+", "");<--- I understand this
                    gsub("[[:space:]]+$", "");<--- I understand this
                    gsub("[[:space:]]+^B", "^B");<--- I dont' know this bit, what does ^B stands for?
                    gsub("^B[[:space:]]+", "^B");<--- I dont' know this bit, what does ^B stands for?

                    if($0 == "")
                            next;

                    print "<option value=\"" $2 "\">" $3 "</option>";

                    next;
            }
            {
                    gsub("[[:space:]]+", " ");
                    gsub("^[[:space:]]+", "");
                    gsub("[[:space:]]+$", "");

                    if($0 == "")
                            next;
            }
    <--- This section is confusing ------>    
            END {
                    printf("cnt=%s\n", cnt);
            }
            '

    

Answer 1

Parece que você está dizendo que parte do que você não entende é a sintaxe do acionador de expressões regulares de awk , que é a que deriva muito do seu poder. Para simplificar, o scaffolding de um script awk pode ser descrito desta forma:

BEGIN {
    Things to do before processing data
}

/needle/  {
    Things to do when a record contains a match for the regex /needle/
}

expression {
    Things to do for each record when the expression evaluates to true (i. e. nonzero)
}

{
    Things to do for all input records
}

END {
    Things to do after all records have been processed
}

Para expandir isso para as linhas de referência:

/^ORA-.*:|^PLS-.*:|^SP2-.*/ {
    stuff
}

/^ORA-.*:|^PLS-.*:|^SP2-.*/ é uma expressão regular que corresponde a qualquer string que corresponda a qualquer um dos seguintes critérios:

• Começa com ORA- , com : após zero ou mais caracteres subsequentes
• Começa com PLA- , com : após zero ou mais caracteres subsequentes
• começa com SP2-

O código nas chaves após essa expressão será executado em qualquer registro que corresponda.

/^ERROR/ {
    stuff
}

Uma expressão regular mais simples que corresponde a qualquer string começando com ERROR .

/\[.*\]\|Error.*/ {
    stuff
}

Outro regex, desta vez correspondendo uma string começando com qualquer coisa com um par de chaves combinadas, ou qualquer coisa com a string Error .

gsub("[[:space:]]+^B", "^B");
gsub("^B[[:space:]]+", "^B");

Estes substituirão qualquer série de caracteres correspondentes a um espaço em branco seguido por um caractere Ctrl + B no primeiro caso, ou a ordem inversa no segundo, com um simples < kbd> Ctrl + B . Lembre-se de que esse caractere de controle foi definido na sub-rotina BEGIN como o separador de campo.