ASCII art diagram converter: Difference between revisions

 

Bonus: perform a thoroughly validation of the input string.

 

=={{header|D}}==

This solution generates anonymous struct code at compile-time, that can be mixed-in inside a struct or class.

import std.conv: text;

import std.format: format;

assert(h.ARCOUNT == 255);

assert(h.Opcode == 7);

{{out}}

<pre>[0, 10, 56, 128, 0, 0, 0, 0, 0, 0, 0, 255]</pre>

 

=={{header|Go}}==

 

import (

hex := "78477bbf5496e12e1bf169a4" // test string

unpack(results, hex)

 

{{out}}

ARCOUNT 16 0110100110100100

</pre>

 

=={{header|J}}==

 

 

soul=: -. {.

starter=:1 :0

0"0 labels normalize m

 

Sample definition (note the deliberate introduction of extraneous whitespace in locations the task requires us to ignore it.

 

+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+

| ID |

get=: sample getter

set=: sample setter

 

Example data for sample definition:

 

4095 13 5 6144 4096 'ID Opcode RCODE ARCOUNT QDCOUNT' set start

4095 0 13 0 0 0 0 0 5 4096 0 0 6144

10 0 7 0 0 0 1 0 0 0 0 0 255

'Opcode' get unpack 0 10 56 128 0 0 0 0 0 0 0 255

 

In other words:

Separate methods to validate, display, decode ASCII art, and decode hex value.

 

import java.math.BigInteger;

import java.util.ArrayList;

 

}

{{out}}

<pre>

 

=={{header|JavaScript}}==

const trimWhitespace = s => s.trim();

const isNotEmpty = s => s !== '';

const alignLeft = n => s => `${s}`.padEnd(n, ' ');

const repeatChar = c => n => c.padStart(n, c);

const printDiagramInfo = map => {

const pName = alignLeft(8);

const line = repeatChar('-');

const res = [];

[...map.values()].forEach(({label, bitLength, start, end}) => {

})

return res;

}, new Map());

 

return hexStr => {

const binString = [...hexStr].reduce(concatHexToBin, '');

 

const res = printDiagramInfo(fieldMetaMap);

 

[...fieldMetaMap.values()].forEach(({label, bitLength, start, end}) => {

})

}

}

const parser = parseDiagram(dia);

 

{{out}}

<pre>

 

 

 

=={{header|Julia}}==

The validator() function can be customized. The one used only checks length.

+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+

| ID |

 

bitreader(decoded, testhexdata)

<pre>

Diagram as bit fields:

ARCOUNT 16 0110100110100100

</pre>

 

=={{header|Nim}}==

Of course, the second mechanism may be used for all cases. The first mechanism is mainly interesting to show how it is possible, using Nim powerful macro system, to create a type ''ex nihilo''.

 

import strutils

import tables

 

# Hexadecimal representation.

 

{{out}}

 

Hexadecimal representation: 78477BBF5496E12E1BF169A4</pre>

 

=={{header|Perl}}==

 

use strict;

 

print "\ntemplate = $template\n\n";

{{out}}

<pre>

=={{header|Phix}}==

Should work on any width, but didn't actually test, or verify width is 8/16/32/64.

{{out}}

<pre>

ARCOUNT, 16 bits: 0110100110100100

</pre>

=={{header|Python}}==

"""

http://rosettacode.org/wiki/ASCII_art_diagram_converter

unpack(results, hex)

 

{{out}}

<b><code>ascii-art-parser.rkt</code></b>

Note that this is in the <code>racket/base</code> language so it doesn't overburden the modules that import it, especially since they're at the suntax phase.

(require (only-in racket/list drop-right)

(only-in racket/string string-trim))

(define cell-end-bit (hash-ref pos->bit-end# (cdr cp)))

(list word cell-start-bit cell-end-bit (string->symbol (string-trim (substring cnt 1))))))))

 

<b><code>ascii-art-reader.rkt</code></b>

(require (for-syntax "ascii-art-parser.rkt"))

(require (for-syntax racket/syntax))

(define rv (make-bytes (* word-size #,(quotient bits/word 8))))

set-fields-bits

 

<b><code>test-ascii-art-reader.rkt</code></b>

(require "ascii-art-reader.rkt")

(require "ascii-art-parser.rkt")

(test

(rfc-1035-header-Z (bytes->rfc-1035-header (rfc-1035-header->bytes h))) => 7

 

{{out}}

{{works with|Rakudo|2018.05}}

 

rule TOP { <.line-separator> [<line> <.line-separator>]+ }

rule line-separator { <.ws> '+--'+ '+' }

say "\nAnd unpack it";

printf("%7s, %02d bits: %s\n", %structure<fields>[$_]<ID>, %structure<fields>[$_]<bits>,

{{out}}

<pre>Line width: 16 bits

=={{header|REXX}}==

Some code was added to the REXX program to validate the input file.

numeric digits 100 /*be able to handle large numbers. */

er= '***error*** illegal input txt' /*a literal used for error messages. */

exit 0 /*stick a fork in it, we're all done. */

/*──────────────────────────────────────────────────────────────────────────────────────*/

{{out|output|text=&nbsp; when using the default input:}}

<pre>

test (hex)= cafe8050800000808080000a length= 24 hexadecimal digits.

 

test (bit)= 10000000 01010000 hex= 80 50

test (bit)= 10000000 00000000 hex= 80 00

</pre>

 

=={{header|Rust}}==

The solution implements a few additional features:

See the output below the source code.

 

 

pub type Bit = bool;

}) => eprintln!("Could not parse the input: {:?}", e),

}

 

{{out}}

 

In this implementation, '''parse''' produces a dictionary from names to bit-lengths. '''encode''' and '''decode''' use these to produce appropriate binary format strings, and then do what they say on the tin. As implemented, this is limited to unsigned numeric values in fields. Supporting unsigned values, strings and enums would require parsing a more complex annotation than only the ASCII art packet structure, but ought not take much more code.

namespace eval asciipacket {

proc assert {expr} { ;# for "static" assertions that throw nice errors

}

}

And here is how to use it with the original test data:

proc test {} {

set header {

}

test

{{Out}}

<pre>

decoded(TC) = 0

decoded(Z) = 100

</pre>