ASCII art diagram converter: Difference between revisions

=={{header|AArch64 Assembly}}==

{{works with|as|Raspberry Pi 3B version Buster 64 bits <br> or android 64 bits with application Termux }}

/* ARM assembly AARCH64 Raspberry PI 3B or android 64 bits */

/* program asciiDiagram64.s */

/* for this file see task include a file in language AArch64 assembly */

.include "../includeARM64.inc"

{{output}}

<pre>

=={{header|ARM Assembly}}==

{{works with|as|Raspberry Pi <br> or android 32 bits with application Termux}}

/* ARM assembly Raspberry PI or android 32 bits */

/* program asciiDiagram.s */

/***************************************************/

.include "../affichage.inc"

{{Output}}

<pre>

Name ARCOUNT value : 0110100110100100

</pre>

=={{header|C}}==

interpret text diagram as data structure

#include <stdlib.h>

#include <stdio.h>

header[BITS] = 0xB50A;

}

{{out}}

<pre>

The ASCII diagram is parsed at compile time into a data structure that is used at runtime to encode and decode the fields.

 

#include <bitset>

#include <iostream>

cout << "Decoded raw data:\n";

Decode<art>(rawData);

{{out}}

<pre>

 

An invalid table will cause a compilation error - here the ANCOUNT field is missing.

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

| ID |

| ARCOUNT |

+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+)";

 

GCC 11 gives this error

=={{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 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:

=={{header|Lua}}==

Provided mainly to illustrate the string-parsing aspect, not necessarily the bit-structure aspect...

local lines = {}

for s in diagram:gmatch("[^\r\n]+") do

local item = schema[i]

print(string.format("%-8s %8d %8d", item.name, item.numbits, item.offset))

{{out}}

<pre>NAME NUMBITS OFFSET

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}}

 

=={{header|Ol}}==

(import (owl parse))

 

(print (car x) " == " (cdr x) " (" (number->string (cdr x) 2) ")"))

datastructure)

{{out}}

<pre>$ ol ascii_art_diagram_converter.scm

 

=={{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>

 

{{libheader|Wren-fmt}}

{{libheader|Wren-big}}

 

var Result = Tuple.create("Result", ["name", "size", "start", "end"])

var results = decode.call(lines)

var hex = "78477bbf5496e12e1bf169a4" // test string

 

{{out}}