{"id":141,"date":"2008-11-06T05:09:25","date_gmt":"2008-11-06T10:09:25","guid":{"rendered":"http:\/\/mariusbancila.ro\/blog\/?p=141"},"modified":"2008-11-07T02:12:42","modified_gmt":"2008-11-07T07:12:42","slug":"parsing-ranges-with-fparsec","status":"publish","type":"post","link":"https:\/\/mariusbancila.ro\/blog\/2008\/11\/06\/parsing-ranges-with-fparsec\/","title":{"rendered":"Parsing ranges with FParsec"},"content":{"rendered":"

FParsec<\/a> is an F# adaptation of Parsec<\/a>, a free monadic parser combinator library for Haskell. It can parse context-sensitive, infinite look-ahead grammars, has complete support for unicode input and large files (> 4 GB) and produces excellent error messages.<\/p>\n

You can download and install it from the above link. To use it in an application, you must add a reference to FParsec.dll and FParsecCS.dll.<\/p>\n

In this post I will use FParsec to parse ranges of numerical values, such as [1-100], and IPs, such as [10.5.10.0-10.5.255.255].<\/p>\n

I will start by defining some types:<\/p>\n

\r\ntype IPAddr = {C1: int64; C2:int64; C3: int64; C4: int64;}\r\ntype TValue = \r\n   | Num of int64\r\n   | IP of IPAddr\r\n\r\ntype Range = {Min : TValue; Max : TValue;}\r\n<\/pre>\n
Having that, I can define a parser for numerical ranges like this:<\/p>\n
\r\nlet p_numrange =\r\n   parse\r\n      {\r\n         do! skipChar '['\r\n         let! a = pint64\r\n         do! skipChar '-'\r\n         let! b = pint64\r\n         do! skipChar ']'\r\n         return {Min = Num a; Max = Num b;}\r\n      }\r\n<\/pre>\n
That can be read like this: make sure it stars with [ byt skip that, parse an numerical value and let that be a, make sure – follows but skip that, parse a second numerical value and let that be b, make sure ] follows but skip that, and it if successful return a Range of a and b.<\/p>\n
To print a Range value I’ll use this function:<\/p>\n
\r\nlet printip (ip:IPAddr) = \r\n   printf \"%d.%d.%d.%d\" ip.C1 ip.C2 ip.C3 ip.C4\r\n   ()\r\n\r\nlet printrange (r:Range) =\r\n   match (r.Min, r.Max) with\r\n   | Num(l1),Num(l2) -> printfn \"Range: %d-%d\" l1 l2\r\n   | IP(ip1),IP(ip2) -> \r\n      printf \"Range: \"\r\n      printip ip1\r\n      printf \"-\"\r\n      printip ip2\r\n      printfn \"\"\r\n   | _ -> ()\r\n   ()\r\n<\/pre>\n
Here is a test<\/p>\n
\r\n   let result = run p_numrange \"[1-100]\"\r\n   match result with\r\n   | Success r -> printrange r\r\n   | Failure (msg, err) -> printf \"%s\\n\" msg\r\n   ()\r\n<\/pre>\n
That outputs:<\/p>\n
\r\nRange: 1-100\r\n<\/pre>\n
Using “(1-100)” instead of “[1-100]” yields the following error message:<\/p>\n
\r\nError in Ln: 1 Col: 1\r\n(1-100)\r\n^\r\nExpecting: '['\r\n\r\n<\/pre>\n
Let’s move forward and define an IP parses. Based on what I did so far this should be pretty easy to understand.<\/p>\n
\r\nlet p_ip =\r\n   parse\r\n      {\r\n         let! c1 = pint64\r\n         do! skipChar '.'\r\n         let! c2 = pint64\r\n         do! skipChar '.'\r\n         let! c3 = pint64\r\n         do! skipChar '.'\r\n         let! c4 = pint64\r\n         return {C1 = c1; C2 = c2; C3 = c3; C4 = c4;}\r\n      }\r\n<\/pre>\n
And an IP range parser would look just like the first range parser, except that pint64 would be replaced by p_ip:<\/p>\n
\r\nlet p_iprange =\r\n   parse\r\n      {\r\n         do! skipChar '['\r\n         let! a = p_ip\r\n         do! skipChar '-'\r\n         let! b = p_ip\r\n         do! skipChar ']'\r\n         return {Min = IP a; Max = IP b;}\r\n      }\r\n<\/pre>\n
Here are some helper functions for testing these parses:<\/p>\n
\r\nlet testrange range =\r\n   let result = run (p_numrange .>> eof) range\r\n   match result with\r\n   | Success r -> printrange r\r\n   | Failure (msg, err) -> printf \"%s\\n\" msg\r\n   ()\r\n\r\nlet testip ip =\r\n   let result = run (p_ip .>> eof) ip \r\n   match result with\r\n   | Success ip -> printip ip; printfn \"\"\r\n   | Failure (msg, err) -> printf \"%s\\n\" msg\r\n   ()   \r\n\r\nlet testiprange range =\r\n   let result = run (p_iprange .>> eof) range\r\n   match result with\r\n   | Success r -> printrange r\r\n   | Failure (msg, err) -> printf \"%s\\n\" msg\r\n   () \r\n<\/pre>\n
You probably noticed the construction “(p_numrange .>> eof)”. That reads: parse a range, and then the end of the file and return the range. That helps us making sure nothing follows the range, like “[1-100] more here”.<\/p>\n
Executing<\/p>\n
\r\ntestrange \"(1-100)\"\r\ntestrange \"[1-100]\"\r\ntestrange \"[1]\"\r\n<\/pre>\n
yields<\/p>\n
\r\nError in Ln: 1 Col: 1\r\n(1-100)\r\n^\r\nExpecting: '['\r\n\r\nRange: 1-100\r\nError in Ln: 1 Col: 3\r\n[1]\r\n  ^\r\nExpecting: '-'\r\n\r\n<\/pre>\n
Executing<\/p>\n
\r\ntestip \"192.168\"\r\ntestip \"192.168.0.1\"\r\ntestip \"192.168.0.1 \"\r\n<\/pre>\n
yields<\/p>\n
\r\nError in Ln: 1 Col: 8\r\n192.168\r\n       ^\r\nExpecting: '.'\r\n\r\n192.168.0.1\r\nError in Ln: 1 Col: 12\r\n192.168.0.1\r\n           ^\r\nExpecting: end of file\r\n\r\n<\/pre>\n
and executing<\/p>\n
\r\ntestiprange \"[10.5.0.1-10.5.255.255]\"\r\ntestiprange \"[10-10.5.255.255]\"\r\n<\/pre>\n
yields<\/p>\n
\r\nRange: 10.5.0.1-10.5.255.255\r\nError in Ln: 1 Col: 4\r\n[10-10.5.255.255]\r\n   ^\r\nExpecting: '.'\r\n\r\n<\/pre>\n
But why defining two range parser? Isn’t possible to have just a single one and specify which parser to use for the values? Yes, it is possible, and that would look like this:<\/p>\n
\r\nlet p_range p =\r\n   parse\r\n      {\r\n         do! skipChar '['\r\n         let! a = p\r\n         do! skipChar '-'\r\n         let! b = p\r\n         do! skipChar ']'\r\n         return {Min = a; Max = b;}\r\n      }\r\n<\/pre>\n
Having that, we can re-define the p_numrange and p_iprange like shown bellow:<\/p>\n
\r\nlet p_ip =\r\n   parse\r\n      {\r\n         let! c1 = pint64\r\n         do! skipChar '.'\r\n         let! c2 = pint64\r\n         do! skipChar '.'\r\n         let! c3 = pint64\r\n         do! skipChar '.'\r\n         let! c4 = pint64\r\n         return IP {C1 = c1; C2 = c2; C3 = c3; C4 = c4;}\r\n      }\r\n      \r\nlet p_int =\r\n   parse\r\n      {\r\n         let! v = pint64\r\n         return Num v\r\n      }\r\n      \r\nlet p_numrange = p_range p_int\r\nlet p_iprange = p_range p_ip      \r\n<\/pre>\n
Everything above would work, except for testip function that needs change to:<\/p>\n
\r\nlet testip ip =\r\n   let result = run (p_ip .>> eof) ip \r\n   match result with\r\n   | Success ip -> match ip with\r\n                   | IP v -> printip v; printfn \"\"\r\n                   | _ -> printfn \"error\"\r\n   | Failure (msg, err) -> printf \"%s\\n\" msg\r\n   ()   \r\n<\/pre>\n
That’s about it about parsing ranges with FParsec.<\/p>\n","protected":false},"excerpt":{"rendered":"
FParsec is an F# adaptation of Parsec, a free monadic parser combinator library for Haskell. It can parse context-sensitive, infinite look-ahead grammars, has complete support for unicode input and large files (> 4 GB) and produces excellent error messages. You can download and install it from the above link. To use it in an application, … Read more<\/a><\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_uag_custom_page_level_css":"","advgb_blocks_editor_width":"","advgb_blocks_columns_visual_guide":"","_jetpack_newsletter_access":"","_jetpack_dont_email_post_to_subs":false,"_jetpack_newsletter_tier_id":0,"_jetpack_memberships_contains_paywalled_content":false,"_jetpack_feature_clip_id":0,"_jetpack_memberships_contains_paid_content":false,"footnotes":"","jetpack_publicize_message":"","jetpack_publicize_feature_enabled":true,"jetpack_social_post_already_shared":false,"jetpack_social_options":{"image_generator_settings":{"template":"highway","default_image_id":0,"font":"","enabled":false},"version":2},"jetpack_post_was_ever_published":false},"categories":[37],"tags":[],"class_list":["post-141","post","type-post","status-publish","format-standard","hentry","category-fsharp"],"aioseo_notices":[],"aioseo_head":"\n\t\t\n\t\n\t\n\t\n\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t