Build a table containing all the ASCII characters and use the awk builtin index() to lookup characters in the table. Then use sprintf() to convert the decimal value returned by index() to hex.

BEGIN {
    for (i = 0; i < 128; i++) {
       table = sprintf("%s%c", table, i);
    }
}

function chartohex (char) {
    return sprintf("0x%x", index(table, char));
}

END { # examples
   print chartohex("a");
   print chartohex("A");
   print chartohex("!");
}

Put this code in the file "foo" and run awk -f foo < /dev/null and you'll see the ASCII values for "a", "A" and "!" printed in hexadecimal.

A lookup table is the only way to address this (directly convert CHAR to ASCII DECIMAL) within "AWK only".

You can simply use sprintf() to convert ASCII DECIMAL to CHAR.

• You can create a lookup table by iterating through each of the known ascii chars and storing them in an array where the key is the character and the value is the ascii value of that char.

• You can use sprintf() within AWK to get the char for each decimal.

• Then you can pass the char to the array to get the corresponding decimal again.

In this example, using awk.

• We cycle through all 256 characters, printing out each one.
• We split the resulting string into a series of lines where each line has a single character.
• We build a table in awk of the 256 characters (in BEGIN), and then feed each of the input characters in to lookup each one.
• Finally we then print out the code for each character on the input.

awk 'BEGIN{
    for(n=0;n<256;n++)
        print sprintf("%c",n)
}' | awk '{
for (i=0; ++i <= length($0);)
    printf "%s\n", substr($0, i, 1)
}' | awk 'BEGIN{
    for(n=0;n<256;n++)
        ord[sprintf("%c",n)]=n
}{
    print ord[$1]
}'

The reverse can also be done, where we lookup a list of character codes.

awk 'BEGIN{
    for(n=0;n<256;n++)
        print sprintf("%s",n)
}' | awk 'BEGIN{
    for(n=0;n<256;n++)
        char[n]=sprintf("%c",n)
}{
    print char[$1]
}'

Note: The second example may print out a lot of garbage in the high ascii range (> 128) depending on the character set you are using.

If you use the GNU awk, then you can include the extended library ordchr:

echo abshdfitiggwigiwjirjgiejrigjr |
    awk -lordchr -F '' '{for(i=1;i<=NF;i++)printf "%c %x\n", i)}'
a 61
b 62
s 73
h 68
...

ord() - function, convert char to decimal
printf "%x", ord($i) - convert decimal to hex
Additionally: chr() - convert decimal to char

Using gawk, from HEX to ASCII

$ gawk  '{ 
           gsub(/../,"0x& "); 
           for(i=1;i<=NF;i++)
              printf("%c", strtonum($i)); 
           print "" 
}' <<<"31323334353637383930313233"
1234567890123

Using any awk

$ cat hex2asc_anyawk.awk 
BEGIN{
    split("0 1 2 3 4 5 6 7 8 9 A B C D E F", d, / /)
    for(i in d)Decimal[d[i]]=i-1
}

function hex2dec(hex,  h,i,j,dec)
{ 
    hex = toupper(hex);                
    i   = length(hex);                 
    while(i)
    {  
          dec += Decimal[substr(hex,i,1)] * 16 ^ j++
          i--                          
    }
    return dec;
}
{

    gsub(/../,"& "); 
    for(i=1;i<=NF;i++)
        printf("%d",hex2dec($i));
    print ""
}

Execution

$ awk -f hex2asc_anyawk.awk <<<"31323334353637383930313233"
1234567890123

Explanation

Steps :

1. Get the decimal equivalent of hex from table.

2. Multiply every digit with 16 power of digit location.

3. Sum all the multipliers.

Example :

BEGIN{
    # Here we created decimal conversion array, like above table
    split("0 1 2 3 4 5 6 7 8 9 A B C D E F", d, / /)
    for(i in d)Decimal[d[i]]=i-1
}

function hex2dec(hex,  h,i,j,dec)
{ 
    hex = toupper(hex);                 # uppercase conversion if any A,B,C,D,E,F
    i   = length(hex);                  # length of hex string
    while(i)
    {  
          # dec var where sum is stored
          # substr(hex,i,1) gives 1 char from RHS
          # multiply by 16 power of digit location 
          dec += Decimal[substr(hex,i,1)] * 16 ^ j++
          i--                           # decrement by 1
    }
    return dec;
}
{
    # it modifies record
    # suppose if given string is 31323334353637383930313233
    # after gsub it becomes 31 32 33 34 35 36 37 38 39 30 31 32 33
    # thus re-evaluate the fields

    gsub(/../,"& "); 

    # loop through fields , NF gives no of fields
    for(i=1;i<=NF;i++)

        # convert from hex to decimal
        # and print equivalent ASCII value 
        printf("%c",hex2dec($i));

    # print newline char
    print ""
}

Meaning of dec += Decimal[substr(hex,i,1)] * 16 ^ j++

dec += Decimal[substr(hex,i,1)] * 16 ^ j++
 ^           ^                    ^
 |           |                    | 
 |           |                    2.Multiply every digit with 16 power of digit location.
 |           |    
 |           1.Gives decimal equivalent of hex
 | 
 | 
 3. Sum all the multipliers 

awk will silently convert strings to numbers. Which number? The number you get by taking the initial decimal digits of the string (this may be just "", if the string is empty or doesn't begin with any decimal digits, as is the case with "A") and converting them to a number. "" gets converted to 0. So all of these would be converted to 0:

• "0"
• "0text"
• "text"
• ""

awk only converts strings to numbers in this way when a number is needed. In "0text" + 1, a number is needed, so the result will be 1. In just plain "0text", a number isn't needed, so no conversion takes place. In printf("%d", "0text"), a number again is needed, so the string will be converted to a number.

What you are looking for is an ord function, which isn't a native function in awk. The gawk documentation describes how to write such a function in awk.

For the first part, try

echo Aa | od -t x1

It prints byte-by-byte

$ echo Aa | od -t x1
0000000 41 61 0a
0000003

The 0a is the implicit newline that echo produces.

Use echo -n or printf instead.

$ printf Aa | od -t x1
0000000 41 61
0000002

iconv -f utf-16be -t ascii input.txt

This code will convert the text 0xA7.0x9B.0x46.0x8D.0x1E.0x52.0xA7.0x9B.0x7B.0x31.0xD2 into a stream of 11 bytes with equivalent values. These bytes will be written to standard out.

TESTDATA=$(echo '0xA7.0x9B.0x46.0x8D.0x1E.0x52.0xA7.0x9B.0x7B.0x31.0xD2' | tr '.' ' ')
for c in $TESTDATA; do
    echo $c | xxd -r
done

As others have pointed out, this will not result in a printable ASCII string for the simple reason that the specified bytes are not ASCII. You need post more information about how you obtained this string for us to help you with that.

How it works: xxd -r translates hexadecimal data to binary (like a reverse hexdump). xxd requires that each line start off with the index number of the first character on the line (run hexdump on something and see how each line starts off with an index number). In our case we want that number to always be zero, since each execution only has one line. As luck would have it, our data already has zeros before every character as part of the 0x notation. The lower case x is ignored by xxd, so all we have to do is pipe each 0xhh character to xxd and let it do the work.

The tr translates periods to spaces so that for will split it up correctly.