I execute hexdump on a data file and it prints out the following :
> hexdump myFile.data
a4c3
After switching byte order I have the following :
c3a4
Do I assume those HEX values are actual Unicode values?
If so, the values are :
and
Or do I take the c3a4 and treat it as UTF-8 data (since my Putty session is set to UTF-8) then convert it to Unicode?
If so, it results into E4 which then is
Which is the proper interpretation?
You cannot assume those hex values are Unicode values. In fact, hexdump will never (well, see below...) give you Unicode values.
Those hex values represent the binary data as it was written to disk when the file was created. But in order to translate that data back to any specific characters/symbols/glyphs, you need to know what specific character encoding was used when the file was created (ASCII, UTF-8, and so on).
Also, I recommend using hexdump with the -C option (that's the uppercase C) to give the so-called "canonical" representation of the hex data:
c3 a4 0a
In my case, there is also a 0a representing a newline character.
So, in the above example we have 0xc3 followed by 0xa4 (I added the 0x part to indicate we are dealing with hex values). I happen to know that this file used UTF-8 when it was created. I can therefore determine that the character in the file is ä (also referred to by Unicode U+00e4).
But the key point is: you must know how the file was encoded, to know with certainty how to interpret the bytes provided by hexdump.
Unicode is (amongst other things) an abstract numbering system for characters, separate from any specific encoding. That is one of the reasons why it is so useful. But it just so happens that its designers used the same encoding as ASCII for the initial set of characters. So that is why ASCII letter a has the same code value as Unicode a. As you can see with Unicode vs. UTF-8, the encodings are not the same, once you get beyond that initial ASCII code range.
I have binary files that contain utf8 strings for example.
4F 00 4B 00
I'm trying to read this data and write it out to a text file but when I do the following:
data.toString('utf8');
I get an output of:
O K
Take note of the two spaces being interpreted from the 00. Is there any way to specify I'm using 2 byte little endian characters? I imagine if this didn't contain ascii characters this would actually break and produce garbage data instead of extra spaces.
The problem likely is when you're reading, not writing the string. The string you shared is not UTF-8, it's UTF-16. So what I'm thinking you want is to read the string as UTF-16 and write it as UTF-8.
Specifically this is UTF-16LE.
I need to extract information from a COBOL program. I'm using the ANTLR grammar for COBOL. I need to extract group variables as a whole. I'm not able to extract this with ANTLR as the parser extracts every variable subdivision/group item as an individual element.
I need somehow to get the group items as a bunch. I'm new to COBOL, so I want to get an understanding of how the compiler understands which elements to include in a group, and where to stop.
EX:
01 EMPREC.
02 EEMPNAME.
10 FIRSTNAME PIC X(10)
10 LASTNAM PIC X(15)
07 SNO PIC X(15)
Is the above definition valid? Will the compiler include all elements(=>2 and <=49) after the first item (01 EMPREC), in the group EMPREC until it encounters another 01 or 77 ? Is this safe to assume?
Is the level information enough to derive what elements fall under a group?
Any pointers is appreciated.
I am the author of the COBOL ANTLR4 grammar you found in the ANTLR4 grammars project. The COBOL grammar generates only an Abstract Syntax Tree (AST).
In contrast, what you ask for is an Abstract Semantic Graph (ASG), which represents grouping of variables and in general relationships between AST elements.
Such an ASG is generated by the COBOL parser at my proleap-cobol-parser project. This project uses the mentioned COBOL grammar and resolves relationships between AST elements.
An example for parsing data description entries can be found in this unit test.
You actually had two questions:
"Is the [...] definition valid?" No it is not as you have no previous level 07. If you change the level of EEMPNAME to 07 or SNO to 02 it is valid. Group items may have a USAGE clause but no PICTURE.
This leads to the question "I want to get an understanding of how the compiler understands which elements to include in a group, and where to stop".
You need to store the level number together with the variable. If you want to know what is part of the group then you need to check this level and all below. If you want to check the complete level 02 group use only the variables with an higher level number below until you get to the next level 02 or a higher level (in this case 01), if you want the
Depending on your needs you additional need to check if the next variable with the same level has a REDEFINES in, in this case it belongs to the same group (storage-wise). Similar applies to level 66 (renames, doesn't have its own storage).
Level 88 has no storage either, it is just for validation entries depending on the parsing you want to do you can ignore them.
Important: level 88 does not create a sub-item, you can have multiple ones and a lower level number afterwards.
The level numbers that always defines a new item are 01, and with extensions 66, 77 and 78.
01 vargroup.
02 var-1 pic 9.
88 var-is-even values 0, 2, 4 6 8 .
88 var-is-not-even values 1 3 5 7 9.
88 var-is-big value 6 thru 9.
02 var-2 pic x.
01 new-var pic x.
77 other-var pic 9.
I suggest to read some COBOL sources and come up with a new question, if necessary. For example CBL_OC_DUMP.
I suspect you are going to need to put some additional code behind your ANTLR parser. If you tokenize each individual item, then keeping up with a stack of group items is somewhat easy. However, trying to grab the entire group item as a single production will be very hard.
Some of the challenges that ANTLR will not be up to are 1) group items can contain group items; 2) group items can redefine other items, or be redefined; 3) the little used, but very complicating level-66 renames clause.
If you treat each numbered data definition as a separate production, and maintain a stack, pushing for new items, popping once you have completed processing an item, and knowing that you have completed a group once you see the same level number again, your life will be easier.
It is quite a while now since I've done COBOL, but there are quite a lot of issues if my memory serves me correctly.
1) 01 levels always start in column 8.
2) When assigning subsiquent levels you are better off incrementing my +5
01 my-record.
05 my-name pic x(30) value spaces.
05 my-address1 pic x(40) value spaces.
3) 77 levels I thought are now obsolete since they are not an efficeint use of memory. Also when 77 levels are used they should always be defined at the start of the working storage section. Obviously record layouts are defined in file section unless using write from and read into?
4) If you are defining lots of new-var pic x. Don't use new 01 levels for each!
01 ws-flages.
05 ws_flag1 pic x value space.
05 ws_flag2 pic x value space.
etc.
For COBOL manuals try Stern & Stern.
Hope this helps!
I got a string of many numbers and was wondering how to go about finding a pattern if there is one without knowing in advance what the pattern might be and what the length of the pattern might be. All it know is that there are only numbers and the maximum range of any given number is 1 - 59.
Example:
12 13 34 45 48 51 56 22 37 30 8 5 47
Although I am starting to think if this was possible it'd be like predicting the future which I don't think it's possible.
If I understand your question correctly, I guess you would like to do something as they do here:
http://alteredqualia.com/visualization/hn/sequence/
http://www.algebra.com/algebra/homework/Sequences-and-series/Sequences-and-series.faq.question.155130.html
That is, looking at the differences between the numbers 1 or more times, and finding patterns. Writing a program to do this for arbitrary sequences is quiet challenging however.
I am a bit confused about encodings. As far as I know old ASCII characters took one byte per character. How many bytes does a Unicode character require?
I assume that one Unicode character can contain every possible character from any language - am I correct? So how many bytes does it need per character?
And what do UTF-7, UTF-6, UTF-16 etc. mean? Are they different versions of Unicode?
I read the Wikipedia article about Unicode but it is quite difficult for me. I am looking forward to seeing a simple answer.
Strangely enough, nobody pointed out how to calculate how many bytes is taking one Unicode char. Here is the rule for UTF-8 encoded strings:
Binary Hex Comments
0xxxxxxx 0x00..0x7F Only byte of a 1-byte character encoding
10xxxxxx 0x80..0xBF Continuation byte: one of 1-3 bytes following the first
110xxxxx 0xC0..0xDF First byte of a 2-byte character encoding
1110xxxx 0xE0..0xEF First byte of a 3-byte character encoding
11110xxx 0xF0..0xF7 First byte of a 4-byte character encoding
So the quick answer is: it takes 1 to 4 bytes, depending on the first one which will indicate how many bytes it'll take up.
You won't see a simple answer because there isn't one.
First, Unicode doesn't contain "every character from every language", although it sure does try.
Unicode itself is a mapping, it defines codepoints and a codepoint is a number, associated with usually a character. I say usually because there are concepts like combining characters. You may be familiar with things like accents, or umlauts. Those can be used with another character, such as an a or a u to create a new logical character. A character therefore can consist of 1 or more codepoints.
To be useful in computing systems we need to choose a representation for this information. Those are the various unicode encodings, such as utf-8, utf-16le, utf-32 etc. They are distinguished largely by the size of of their codeunits. UTF-32 is the simplest encoding, it has a codeunit that is 32bits, which means an individual codepoint fits comfortably into a codeunit. The other encodings will have situations where a codepoint will need multiple codeunits, or that particular codepoint can't be represented in the encoding at all (this is a problem for instance with UCS-2).
Because of the flexibility of combining characters, even within a given encoding the number of bytes per character can vary depending on the character and the normalization form. This is a protocol for dealing with characters which have more than one representation (you can say "an 'a' with an accent" which is 2 codepoints, one of which is a combining char or "accented 'a'" which is one codepoint).
I know this question is old and already has an accepted answer, but I want to offer a few examples (hoping it'll be useful to someone).
As far as I know old ASCII characters took one byte per character.
Right. Actually, since ASCII is a 7-bit encoding, it supports 128 codes (95 of which are printable), so it only uses half a byte (if that makes any sense).
How many bytes does a Unicode character require?
Unicode just maps characters to codepoints. It doesn't define how to encode them. A text file does not contain Unicode characters, but bytes/octets that may represent Unicode characters.
I assume that one Unicode character can contain every possible
character from any language - am I correct?
No. But almost. So basically yes. But still no.
So how many bytes does it need per character?
Same as your 2nd question.
And what do UTF-7, UTF-6, UTF-16 etc mean? Are they some kind Unicode
versions?
No, those are encodings. They define how bytes/octets should represent Unicode characters.
A couple of examples. If some of those cannot be displayed in your browser (probably because the font doesn't support them), go to http://codepoints.net/U+1F6AA (replace 1F6AA with the codepoint in hex) to see an image.
U+0061 LATIN SMALL LETTER A: a
Nº: 97
UTF-8: 61
UTF-16: 00 61
U+00A9 COPYRIGHT SIGN: ©
Nº: 169
UTF-8: C2 A9
UTF-16: 00 A9
U+00AE REGISTERED SIGN: ®
Nº: 174
UTF-8: C2 AE
UTF-16: 00 AE
U+1337 ETHIOPIC SYLLABLE PHWA: ጷ
Nº: 4919
UTF-8: E1 8C B7
UTF-16: 13 37
U+2014 EM DASH: —
Nº: 8212
UTF-8: E2 80 94
UTF-16: 20 14
U+2030 PER MILLE SIGN: ‰
Nº: 8240
UTF-8: E2 80 B0
UTF-16: 20 30
U+20AC EURO SIGN: €
Nº: 8364
UTF-8: E2 82 AC
UTF-16: 20 AC
U+2122 TRADE MARK SIGN: ™
Nº: 8482
UTF-8: E2 84 A2
UTF-16: 21 22
U+2603 SNOWMAN: ☃
Nº: 9731
UTF-8: E2 98 83
UTF-16: 26 03
U+260E BLACK TELEPHONE: ☎
Nº: 9742
UTF-8: E2 98 8E
UTF-16: 26 0E
U+2614 UMBRELLA WITH RAIN DROPS: ☔
Nº: 9748
UTF-8: E2 98 94
UTF-16: 26 14
U+263A WHITE SMILING FACE: ☺
Nº: 9786
UTF-8: E2 98 BA
UTF-16: 26 3A
U+2691 BLACK FLAG: ⚑
Nº: 9873
UTF-8: E2 9A 91
UTF-16: 26 91
U+269B ATOM SYMBOL: ⚛
Nº: 9883
UTF-8: E2 9A 9B
UTF-16: 26 9B
U+2708 AIRPLANE: ✈
Nº: 9992
UTF-8: E2 9C 88
UTF-16: 27 08
U+271E SHADOWED WHITE LATIN CROSS: ✞
Nº: 10014
UTF-8: E2 9C 9E
UTF-16: 27 1E
U+3020 POSTAL MARK FACE: 〠
Nº: 12320
UTF-8: E3 80 A0
UTF-16: 30 20
U+8089 CJK UNIFIED IDEOGRAPH-8089: 肉
Nº: 32905
UTF-8: E8 82 89
UTF-16: 80 89
U+1F4A9 PILE OF POO: 💩
Nº: 128169
UTF-8: F0 9F 92 A9
UTF-16: D8 3D DC A9
U+1F680 ROCKET: 🚀
Nº: 128640
UTF-8: F0 9F 9A 80
UTF-16: D8 3D DE 80
Okay I'm getting carried away...
Fun facts:
If you're looking for a specific character, you can copy&paste it on http://codepoints.net/.
I wasted a lot of time on this useless list (but it's sorted!).
MySQL has a charset called "utf8" which actually does not support characters longer than 3 bytes. So you can't insert a pile of poo, the field will be silently truncated. Use "utf8mb4" instead.
There's a snowman test page (unicodesnowmanforyou.com).
Simply speaking Unicode is a standard which assigned one number (called code point) to all characters of the world (Its still work in progress).
Now you need to represent this code points using bytes, thats called character encoding. UTF-8, UTF-16, UTF-6 are ways of representing those characters.
UTF-8 is multibyte character encoding. Characters can have 1 to 6 bytes (some of them may be not required right now).
UTF-32 each characters have 4 bytes a characters.
UTF-16 uses 16 bits for each character and it represents only part of Unicode characters called BMP (for all practical purposes its enough). Java uses this encoding in its strings.
In UTF-8:
1 byte: 0 - 7F (ASCII)
2 bytes: 80 - 7FF (all European plus some Middle Eastern)
3 bytes: 800 - FFFF (multilingual plane incl. the top 1792 and private-use)
4 bytes: 10000 - 10FFFF
In UTF-16:
2 bytes: 0 - D7FF (multilingual plane except the top 1792 and private-use )
4 bytes: D800 - 10FFFF
In UTF-32:
4 bytes: 0 - 10FFFF
10FFFF is the last unicode codepoint by definition, and it's defined that way because it's UTF-16's technical limit.
It is also the largest codepoint UTF-8 can encode in 4 byte, but the idea behind UTF-8's encoding also works for 5 and 6 byte encodings to cover codepoints until 7FFFFFFF, ie. half of what UTF-32 can.
In Unicode the answer is not easily given. The problem, as you already pointed out, are the encodings.
Given any English sentence without diacritic characters, the answer for UTF-8 would be as many bytes as characters and for UTF-16 it would be number of characters times two.
The only encoding where (as of now) we can make the statement about the size is UTF-32. There it's always 32bit per character, even though I imagine that code points are prepared for a future UTF-64 :)
What makes it so difficult are at least two things:
composed characters, where instead of using the character entity that is already accented/diacritic (À), a user decided to combine the accent and the base character (`A).
code points. Code points are the method by which the UTF-encodings allow to encode more than the number of bits that gives them their name would usually allow. E.g. UTF-8 designates certain bytes which on their own are invalid, but when followed by a valid continuation byte will allow to describe a character beyond the 8-bit range of 0..255. See the Examples and Overlong Encodings below in the Wikipedia article on UTF-8.
The excellent example given there is that the € character (code point U+20AC can be represented either as three-byte sequence E2 82 AC or four-byte sequence F0 82 82 AC.
Both are valid, and this shows how complicated the answer is when talking about "Unicode" and not about a specific encoding of Unicode, such as UTF-8 or UTF-16. Strictly speaking, as pointed out in a comment, this doesn't seem to be the case any longer or was even based on a misunderstanding on my part. The quote from the updated Wikipedia article reads: Longer encodings are called overlong and are not valid UTF-8 representations of the code point.
There is a great tool for calculating the bytes of any string in UTF-8: http://mothereff.in/byte-counter
Update: #mathias has made the code public: https://github.com/mathiasbynens/mothereff.in/blob/master/byte-counter/eff.js
Well I just pulled up the Wikipedia page on it too, and in the intro portion I saw "Unicode can be implemented by different character encodings. The most commonly used encodings are UTF-8 (which uses one byte for any ASCII characters, which have the same code values in both UTF-8 and ASCII encoding, and up to four bytes for other characters), the now-obsolete UCS-2 (which uses two bytes for each character but cannot encode every character in the current Unicode standard)"
As this quote demonstrates, your problem is that you are assuming Unicode is a single way of encoding characters. There are actually multiple forms of Unicode, and, again in that quote, one of them even has 1 byte per character just like what you are used to.
So your simple answer that you want is that it varies.
Unicode is a standard which provides a unique number for every character. These unique numbers are called code points (which is just unique code) to all characters existing in the world (some's are still to be added).
For different purposes, you might need to represent this code points in bytes (most programming languages do so), and here's where Character Encoding kicks in.
UTF-8, UTF-16, UTF-32 and so on are all Character Encodings, and Unicode's code points are represented in these encodings, in different ways.
UTF-8 encoding has a variable-width length, and characters, encoded in it, can occupy 1 to 4 bytes inclusive;
UTF-16 has a variable length and characters, encoded in it, can take either 1 or 2 bytes (which is 8 or 16 bits). This represents only part of all Unicode characters called BMP (Basic Multilingual Plane) and it's enough for almost all the cases. Java uses UTF-16 encoding for its strings and characters;
UTF-32 has fixed length and each character takes exactly 4 bytes (32 bits).
For UTF-16, the character needs four bytes (two code units) if it starts with 0xD800 or greater; such a character is called a "surrogate pair." More specifically, a surrogate pair has the form:
[0xD800 - 0xDBFF] [0xDC00 - 0xDFF]
where [...] indicates a two-byte code unit with the given range. Anything <= 0xD7FF is one code unit (two bytes). Anything >= 0xE000 is invalid (except BOM markers, arguably).
See http://unicodebook.readthedocs.io/unicode_encodings.html, section 7.5.
Check out this Unicode code converter. For example, enter 0x2009, where 2009 is the Unicode number for thin space, in the "0x... notation" field, and click Convert. The hexadecimal number E2 80 89 (3 bytes) appears in the "UTF-8 code units" field.
From Wiki:
UTF-8, an 8-bit variable-width encoding which maximizes compatibility with ASCII;
UTF-16, a 16-bit, variable-width encoding;
UTF-32, a 32-bit, fixed-width encoding.
These are the three most popular different encoding.
In UTF-8 each character is encoded into 1 to 4 bytes ( the dominant encoding )
In UTF16 each character is encoded into 1 to two 16-bit words and
in UTF-32 every character is encoded as a single 32-bit word.