master..336df25 · typeable/hexml

git.iko.soy/typeable/hexml

on 336df25 help sign in

.ghci+1−1

since splitsnapshots

unifiedsplit

@@ -1,4 +1,4 @@

1−:set -Wunused-binds -Wunused-imports -Worphans

1+:set -fwarn-unused-binds -fwarn-unused-imports -fwarn-orphans

2:set -isrc

3:load Main

.github/workflows/ci.ymldeleted−33

@@ -1,33 +0,0 @@

1−name: ci

2−on:

3− push:

4− pull_request:

5− schedule:

6− - cron: '0 3 * * 6' # 3am Saturday

7−jobs:

8− test:

9− runs-on: ${{ matrix.os }}

10−

11− strategy:

12− fail-fast: false

13− matrix:

14− os: [ubuntu-latest]

15− ghc: ['9.6', '9.4', '9.2', '9.0', '8.10', '8.8']

16− include:

17− - os: windows-latest

18− - os: macOS-latest

19−

20− steps:

21− - run: git config --global core.autocrlf false

22− - uses: actions/checkout@v2

23− - uses: haskell/actions/setup@v2

24− id: setup-haskell

25− with:

26− ghc-version: ${{ matrix.ghc }}

27− - run: cabal v2-freeze --enable-tests

28− - uses: actions/cache@v2

29− with:

30− path: ${{ steps.setup-haskell.outputs.cabal-store }}

31− key: ${{ runner.os }}-${{ matrix.ghc }}-${{ hashFiles('cabal.project.freeze') }}

32− restore-keys: ${{ runner.os }}-${{ matrix.ghc }}-

33− - uses: ndmitchell/neil@master

.travis.ymlnew file+13

@@ -0,0 +1,13 @@

1+sudo: required

2+env:

3+- GHCVER=7.6.3

4+- GHCVER=7.8.4

5+- GHCVER=7.10.3

6+- GHCVER=8.0.2

7+- GHCVER=8.2.1

8+- GHCVER=8.4.1

9+- GHCVER=head

10+

11+script:

12+- curl -sL https://raw.github.com/ndmitchell/neil/master/travis.sh | sh

13+- sh afl.sh

CHANGES.txt−2

@@ -1,7 +1,5 @@

1Changelog for Hexml

3−0.3.4, released 2018-09-10

4− #15, licensed under BSD-3-Clause OR Apache-2.0

50.3.3, released 2017-10-27

30.3.3, released 2017-10-27

6 #13, allow the . character in tags and attributes

4 #13, allow the . character in tags and attributes

70.3.2, released 2017-05-22

50.3.2, released 2017-05-22

LICENSE+3−190

@@ -1,20 +1,9 @@

1−Copyright Neil Mitchell 2016-2023.

1+Copyright Neil Mitchell 2018.

2−

3−Licensed under either of:

4−

5−* BSD-3-Clause license (https://opensource.org/licenses/BSD-3-Clause)

6−* Apache License, version 2.0 (https://opensource.org/licenses/Apache-2.0)

7−

8−As a user, you may use this code under either license, at your option.

9−

10−

11−---------------------------------------------------------------------

12−BSD 3-Clause License

13All rights reserved.

2All rights reserved.

15Redistribution and use in source and binary forms, with or without

4Redistribution and use in source and binary forms, with or without

16−modification, are permitted provided that the following conditions

5+modification, are permitted provided that the following conditions are

17−are met:

6+met:

19 * Redistributions of source code must retain the above copyright

8 * Redistributions of source code must retain the above copyright

20 notice, this list of conditions and the following disclaimer.

9 notice, this list of conditions and the following disclaimer.

@@ -39,179 +28,3 @@ DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

39THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

28THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

40(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

29(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

41OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

30OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

42−

43−

44−---------------------------------------------------------------------

45−Apache License

46−Version 2.0, January 2004

47−<http://www.apache.org/licenses/>

48−

49−Terms and Conditions for use, reproduction, and distribution

50−1. Definitions

51−"License" shall mean the terms and conditions for use, reproduction,

52−and distribution as defined by Sections 1 through 9 of this document.

53−

54−"Licensor" shall mean the copyright owner or entity authorized by the

55−copyright owner that is granting the License.

56−

57−"Legal Entity" shall mean the union of the acting entity and all

58−other entities that control, are controlled by, or are under common

59−control with that entity. For the purposes of this definition,

60−"control" means (i) the power, direct or indirect, to cause the

61−direction or management of such entity, whether by contract or

62−otherwise, or (ii) ownership of fifty percent (50%) or more of the

63−outstanding shares, or (iii) beneficial ownership of such entity.

64−

65−"You" (or "Your") shall mean an individual or Legal Entity exercising

66−permissions granted by this License.

67−

68−"Source" form shall mean the preferred form for making modifications,

69−including but not limited to software source code, documentation

70−source, and configuration files.

71−

72−"Object" form shall mean any form resulting from mechanical

73−transformation or translation of a Source form, including but not

74−limited to compiled object code, generated documentation, and

75−conversions to other media types.

76−

77−"Work" shall mean the work of authorship, whether in Source or Object

78−form, made available under the License, as indicated by a copyright

79−notice that is included in or attached to the work).

80−

81−"Derivative Works" shall mean any work, whether in Source or Object

82−form, that is based on (or derived from) the Work and for which the

83−editorial revisions, annotations, elaborations, or other

84−modifications represent, as a whole, an original work of authorship.

85−For the purposes of this License, Derivative Works shall not include

86−works that remain separable from, or merely link (or bind by name) to

87−the interfaces of, the Work and Derivative Works thereof.

88−

89−"Contribution" shall mean any work of authorship, including the

90−original version of the Work and any modifications or additions to

91−that Work or Derivative Works thereof, that is intentionally

92−submitted to Licensor for inclusion in the Work by the copyright

93−owner or by an individual or Legal Entity authorized to submit on

94−behalf of the copyright owner. For the purposes of this definition,

95−"submitted" means any form of electronic, verbal, or written

96−communication sent to the Licensor or its representatives, including

97−but not limited to communication on electronic mailing lists, source

98−code control systems, and issue tracking systems that are managed by,

99−or on behalf of, the Licensor for the purpose of discussing and

100−improving the Work, but excluding communication that is conspicuously

101−marked or otherwise designated in writing by the copyright owner as

102−"Not a Contribution."

103−

104−"Contributor" shall mean Licensor and any individual or Legal Entity

105−on behalf of whom a Contribution has been received by Licensor and

106−subsequently incorporated within the Work.

107−

108−2. Grant of Copyright License

109−Subject to the terms and conditions of this License, each Contributor

110−hereby grants to You a perpetual, worldwide, non-exclusive,

111−no-charge, royalty-free, irrevocable copyright license to reproduce,

112−prepare Derivative Works of, publicly display, publicly perform,

113−sublicense, and distribute the Work and such Derivative Works in

114−Source or Object form.

115−

116−3. Grant of Patent License

117−Subject to the terms and conditions of this License, each Contributor

118−hereby grants to You a perpetual, worldwide, non-exclusive,

119−no-charge, royalty-free, irrevocable (except as stated in this

120−section) patent license to make, have made, use, offer to sell, sell,

121−import, and otherwise transfer the Work, where such license applies

122−only to those patent claims licensable by such Contributor that are

123−necessarily infringed by their Contribution(s) alone or by

124−combination of their Contribution(s) with the Work to which such

125−Contribution(s) was submitted. If You institute patent litigation

126−against any entity (including a cross-claim or counterclaim in a

127−lawsuit) alleging that the Work or a Contribution incorporated within

128−the Work constitutes direct or contributory patent infringement, then

129−any patent licenses granted to You under this License for that Work

130−shall terminate as of the date such litigation is filed.

131−

132−4. Redistribution

133−You may reproduce and distribute copies of the Work or Derivative

134−Works thereof in any medium, with or without modifications, and in

135−Source or Object form, provided that You meet the following

136−conditions:

137−

138−(a) You must give any other recipients of the Work or Derivative

139−Works a copy of this License; and

140−(b) You must cause any modified files to carry prominent notices

141−stating that You changed the files; and

142−(c) You must retain, in the Source form of any Derivative Works that

143−You distribute, all copyright, patent, trademark, and attribution

144−notices from the Source form of the Work, excluding those notices

145−that do not pertain to any part of the Derivative Works; and

146−(d) If the Work includes a "NOTICE" text file as part of its

147−distribution, then any Derivative Works that You distribute must

148−include a readable copy of the attribution notices contained within

149−such NOTICE file, excluding those notices that do not pertain to any

150−part of the Derivative Works, in at least one of the following

151−places: within a NOTICE text file distributed as part of the

152−Derivative Works; within the Source form or documentation, if

153−provided along with the Derivative Works; or, within a display

154−generated by the Derivative Works, if and wherever such third-party

155−notices normally appear. The contents of the NOTICE file are for

156−informational purposes only and do not modify the License. You may

157−add Your own attribution notices within Derivative Works that You

158−distribute, alongside or as an addendum to the NOTICE text from the

159−Work, provided that such additional attribution notices cannot be

160−construed as modifying the License.

161−You may add Your own copyright statement to Your modifications and

162−may provide additional or different license terms and conditions for

163−use, reproduction, or distribution of Your modifications, or for any

164−such Derivative Works as a whole, provided Your use, reproduction,

165−and distribution of the Work otherwise complies with the conditions

166−stated in this License.

167−

168−5. Submission of Contributions

169−Unless You explicitly state otherwise, any Contribution intentionally

170−submitted for inclusion in the Work by You to the Licensor shall be

171−under the terms and conditions of this License, without any

172−additional terms or conditions. Notwithstanding the above, nothing

173−herein shall supersede or modify the terms of any separate license

174−agreement you may have executed with Licensor regarding such

175−Contributions.

176−

177−6. Trademarks

178−This License does not grant permission to use the trade names,

179−trademarks, service marks, or product names of the Licensor, except

180−as required for reasonable and customary use in describing the origin

181−of the Work and reproducing the content of the NOTICE file.

182−

183−7. Disclaimer of Warranty

184−Unless required by applicable law or agreed to in writing, Licensor

185−provides the Work (and each Contributor provides its Contributions)

186−on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,

187−either express or implied, including, without limitation, any

188−warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY,

189−or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for

190−determining the appropriateness of using or redistributing the Work

191−and assume any risks associated with Your exercise of permissions

192−under this License.

193−

194−8. Limitation of Liability

195−In no event and under no legal theory, whether in tort (including

196−negligence), contract, or otherwise, unless required by applicable

197−law (such as deliberate and grossly negligent acts) or agreed to in

198−writing, shall any Contributor be liable to You for damages,

199−including any direct, indirect, special, incidental, or consequential

200−damages of any character arising as a result of this License or out

201−of the use or inability to use the Work (including but not limited to

202−damages for loss of goodwill, work stoppage, computer failure or

203−malfunction, or any and all other commercial damages or losses), even

204−if such Contributor has been advised of the possibility of such

205−damages.

206−

207−9. Accepting Warranty or Additional Liability

208−While redistributing the Work or Derivative Works thereof, You may

209−choose to offer, and charge a fee for, acceptance of support,

210−warranty, indemnity, or other liability obligations and/or rights

211−consistent with this License. However, in accepting such obligations,

212−You may act only on Your own behalf and on Your sole responsibility,

213−not on behalf of any other Contributor, and only if You agree to

214−indemnify, defend, and hold each Contributor harmless for any

215−liability incurred by, or claims asserted against, such Contributor

216−by reason of your accepting any such warranty or additional

217−liability.

PULL_REQUEST_TEMPLATE.mddeleted−5

@@ -1,5 +0,0 @@

1−Thanks for the pull request!

2−

3−By raising this pull request you confirm you are licensing your contribution under all licenses that apply to this project (see LICENSE) and that you have no patents covering your contribution.

4−

5−If you care, my PR preferences are at https://github.com/ndmitchell/neil#contributions, but they're all guidelines, and I'm not too fussy - you don't have to read them.

README.md+2−4

@@ -1,4 +1,4 @@

1−# Hexml [![Hackage version](https://img.shields.io/hackage/v/hexml.svg?label=Hackage)](https://hackage.haskell.org/package/hexml) [![Stackage version](https://www.stackage.org/package/hexml/badge/nightly?label=Stackage)](https://www.stackage.org/package/hexml) [![Build status](https://img.shields.io/github/actions/workflow/status/ndmitchell/hexml/ci.yml?branch=master)](https://github.com/ndmitchell/hexml/actions)

1+# Hexml [![Hackage version](https://img.shields.io/hackage/v/hexml.svg?label=Hackage)](https://hackage.haskell.org/package/hexml) [![Stackage version](https://www.stackage.org/package/hexml/badge/lts?label=Stackage)](https://www.stackage.org/package/hexml) [![Linux Build Status](https://img.shields.io/travis/ndmitchell/hexml.svg?label=Linux%20build)](https://travis-ci.org/ndmitchell/hexml) [![Windows Build Status](https://img.shields.io/appveyor/ci/ndmitchell/hexml.svg?label=Windows%20build)](https://ci.appveyor.com/project/ndmitchell/hexml)

3An XML DOM-style parser, that only parses a subset of XML, but is designed to be fast. In particular:

@@ -8,10 +8,8 @@ An XML DOM-style parser, that only parses a subset of XML, but is designed to be

9The name "hexml" is a combination of "Hex" (a curse) and "XML". The "X" should not be capitalised because the parser is more curse and less XML.

11−Hexml may be suitable if you want to quickly parse XML, from known sources, and a full XML parser has been shown to be a bottleneck. As an alternative to hexml, which supports things like entities but is still pretty fast, see [Pugixml](http://pugixml.org/) (with a [Haskell binding](https://hackage.haskell.org/package/pugixml) - but be aware the Haskell binding [can segfault](https://github.com/philopon/pugixml-hs/issues/5)).

11+Hexml may be suitable if you want to quickly parse XML, from known sources, and a full XML parser has been shown to be a bottleneck. As an alternative to hexml, which supports things like entities but is still pretty fast, see [Pugixml](http://pugixml.org/) (with a [Haskell binding](https://hackage.haskell.org/package/pugixml)).

13Hexml is tested with [AFL](http://lcamtuf.coredump.cx/afl/).

15If you want lenses for Hexml, see [hexml-lens](http://hackage.haskell.org/package/hexml-lens).

16−

17−The optimisation work around Hexml spawned [Xeno](http://hackage.haskell.org/package/xeno), a Haskell-only alternative to Hexml. There is a [talk](https://ndmitchell.com/#hexml_12_oct_2017) covering the performance tricks of Hexml and Xeno.

appveyor.ymlnew file+5

@@ -0,0 +1,5 @@

1+build: off

2+cache: "c:\\sr -> appveyor.yml"

4+test_script:

5+- ps: Invoke-Expression (Invoke-WebRequest 'https://raw.githubusercontent.com/ndmitchell/neil/master/appveyor.ps1')

cbits/hexml.c+2−2

@@ -40,7 +40,7 @@ typedef struct

40 // have a cursor at the end, which is stack scoped, so children write out, then I do

41 // when you commit, you copy over from end to front

43− // nodes

43+ // nodes

44 int size;

45 int used_front; // front entries, stored for good

46 int used_back; // back entries, stack based, copied into front

@@ -539,7 +539,7 @@ document* hexml_document_parse(const char* s, int slen)

539 d->nodes.nodes[0].outer = start_length(0, slen);

540 d->nodes.nodes[0].inner = start_length(0, slen);

541 d->nodes.nodes[0].attrs = start_length(0, 0);

542−

542+

543 // Introduce an intermediate result, otherwise behaviour is undefined

544 // because there is no guaranteed ordering between LHS and RHS evaluation

545 str content = parse_content(d);

cbits/hexml.h−1

@@ -21,7 +21,6 @@ typedef struct

21 str name; // tag name, e.g. <[foo]>

22 str inner; // inner text, <foo>[bar]</foo>

23 str outer; // outer text, [<foo>bar</foo>]

24− // Not usable, but required to get the correct sizing when returning arrays of nodes

25 str attrs; // all the attributes, in the attribute buffer (not usable)

24 str attrs; // all the attributes, in the attribute buffer (not usable)

26 str nodes; // all the nodes, in the node buffer (not usable)

25 str nodes; // all the nodes, in the node buffer (not usable)

27} node;

26} node;

gen/Lib.hs+5−5

@@ -10,7 +10,7 @@ module Lib(

10import Control.Monad.Extra

11import Control.Monad.Trans.Writer

12import Data.Maybe

13−import Data.List.Extra

13+import Data.List

14import Data.Bits

15import Data.Monoid

16import Numeric

@@ -67,7 +67,7 @@ choices :: [Parser o ()] -> Parser o ()

67choices = foldr1 choice

69optional :: Parser o () -> Parser o ()

70−optional x = choice x $ pure ()

70+optional x = choice x $ return ()

73---------------------------------------------------------------------

@@ -102,11 +102,11 @@ implies known x = all (fromCharSet x) poss

102

103charSetC :: [CharSet] -> ([String], CharSet -> String)

104charSetC sets =

105− (["static const char table[256] = {" ++ intercalate "," ("0":map disp chars) ++ "};"]

105+ (["static const char internal_parse_table[256] = {" ++ intercalate "," ("0":map disp chars) ++ "};"]

106− ,\x -> fromMaybe ("table[(int) *p] & " ++ showBit (bit $ fromJust $ elemIndex x hard)) $ simple x)

106+ ,\x -> fromMaybe ("internal_parse_table[*p] & " ++ showBit (bit $ fromJust $ elemIndex x hard)) $ simple x)

107 where

108 showBit x = "0x" ++ showHex (x :: Int) ""

109− disp c = showBit $ foldr (.|.) 0 [bit i | (i, h) <- zipFrom 0 hard, fromCharSet h c]

109+ disp c = showBit $ foldr (.|.) 0 [bit i | (i, h) <- zip [0..] hard, fromCharSet h c]

110

111 hard = nub $ filter (isNothing . simple) sets

112

gen/Main.hs+3−3

@@ -23,18 +23,18 @@ main = do

23 putStrLn $ rerender src res

24 writeFileChanged "test.h" $ unlines $ compile html

25 buildRule ["test.h","test.c"] ["gen" <.> (if isWindows then "exe" else "")] $

26− system_ "gcc test.c -o gen -Werror -Wall -Wextra -DTEST"

26+ system_ "gcc test.c -o gen -Werror"

27 system_ "gen"

29writeFileChanged :: FilePath -> String -> IO ()

30writeFileChanged file new = do

31− old <- ifM (doesFileExist file) (readFile' file) (pure "")

31+ old <- ifM (doesFileExist file) (readFile' file) (return "")

32 when (old /= new) $

33 writeFile file new

35buildRule :: [FilePath] -> [FilePath] -> IO () -> IO ()

36buildRule from to act = do

37− let modTime x = ifM (doesFileExist x) (Just <$> getModificationTime x) (pure Nothing)

37+ let modTime x = ifM (doesFileExist x) (Just <$> getModificationTime x) (return Nothing)

38 from <- mapM modTime from

39 to <- mapM modTime to

40 when (any isNothing (from ++ to) || maximum from >= minimum to)

gen/Parser.hs+3−5

@@ -13,7 +13,7 @@ data Out

14is lower upper x = x >= lower && x <= upper

15isName1 x = x == ':' || x == '_' || is 'a' 'z' x || is 'A' 'Z' x

16−isName x = isName1 x || x == '-' || x == '.' || is '0' '9' x

16+isName x = isName1 x || x == '-' || is '0' '9' x

17isSpace x = x == ' ' || x == '\t' || x == '\r' || x == '\n'

19whitespace = many $ match isSpace

@@ -22,8 +22,8 @@ name = do

22 out NameStart

23 match isName1

24 many $ match isName

25− out NameEnd

26 whitespace

25 whitespace

26+ out NameEnd

28attrib = do

29 name

@@ -52,9 +52,7 @@ tag = do

52 let name_ = name `choice` abort "Missing tag name"

53 choices

54 [do lit "!--"

55− many $ match (/= '-')

56− -- FIXME: Not correct!!!

55+ many $ lit "-->" -- FIXME: Not correct!!!

57− lit "-->"

58 out TagComment

56 out TagComment

59 ,do lit "?"

57 ,do lit "?"

60 name_

58 name_

gen/test.c+65−186

@@ -3,8 +3,11 @@

3#include <stdlib.h>

4#include <string.h>

5#include <assert.h>

6+#include <ctype.h>

6#include <stdio.h>

7#include <stdio.h>

9+typedef int bool;

10+

8/////////////////////////////////////////////////////////////////////

11/////////////////////////////////////////////////////////////////////

9// TYPES

12// TYPES

@@ -41,8 +44,7 @@ typedef struct

41 // nodes

44 // nodes

42 int size;

45 int size;

43 int used_front; // front entries, stored for good

46 int used_front; // front entries, stored for good

44− int used_back; // back entries, stack based, copied into front on </close>

47+ int used_back; // back entries, stack based, copied into front

45− // back entries which haven't yet been closed have nodes.length == -1

46 node* nodes; // dynamically allocated buffer

48 node* nodes; // dynamically allocated buffer

47 node* alloc; // what to call free on

49 node* alloc; // what to call free on

48} node_buffer;

50} node_buffer;

@@ -51,24 +53,30 @@ typedef struct

51struct document

53struct document

52{

54{

53 const char* body; // pointer to initial argument, not owned by us

55 const char* body; // pointer to initial argument, not owned by us

54− int body_len; // length of the body

56+

57+ // things only used while parsing

58+ const char* cursor; // pointer to where we are in body

59+ const char* end; // pointer to one past the last char

60+ // if cursor is > end we have gone past the end

56 char* error_message;

62 char* error_message;

57 node_buffer nodes;

63 node_buffer nodes;

58 attr_buffer attrs;

64 attr_buffer attrs;

59};

65};

67+static inline int doc_length(const document* d) { return (int) (d->end - d->body); }

68+static inline int doc_position(const document* d) { return (int) (d->cursor - d->body); }

69+

62/////////////////////////////////////////////////////////////////////

71/////////////////////////////////////////////////////////////////////

63// RENDER CODE

72// RENDER CODE

65typedef struct

74typedef struct

66{

75{

67− const document* d; // Document, used to get at the body

76+ const document* d;

68− char* buffer; // Buffer we are writing too

77+ char* buffer;

69− int length; // Length of buffer, do not write past the end.

78+ int length;

70− // No character is reserved for a NULL terminator.

79+ int cursor;

71− int cursor; // Cursor of where we are writing now

72} render;

80} render;

74static inline void render_char(render* r, char c)

82static inline void render_char(render* r, char c)

@@ -92,7 +100,7 @@ static inline void bound_str(str s, int mn, int mx)

100

93static void render_str(render* r, str s)

101static void render_str(render* r, str s)

94{

102{

95− bound_str(s, 0, r->d->body_len);

103+ bound_str(s, 0, doc_length(r->d));

96 for (int i = 0; i < s.length; i++)

104 for (int i = 0; i < s.length; i++)

97 render_char(r, r->d->body[s.start + i]);

105 render_char(r, r->d->body[s.start + i]);

98}

106}

@@ -101,7 +109,7 @@ static void render_tag(render* r, const node* n);

101

109

102static void render_content(render* r, const node* n)

110static void render_content(render* r, const node* n)

103{

111{

104− bound_str(n->inner, 0, r->d->body_len);

112+ bound_str(n->inner, 0, doc_length(r->d));

105 bound_str(n->nodes, 0, r->d->nodes.used_front);

113 bound_str(n->nodes, 0, r->d->nodes.used_front);

106 bound_str(n->attrs, 0, r->d->attrs.used);

114 bound_str(n->attrs, 0, r->d->attrs.used);

107

115

@@ -180,6 +188,7 @@ attr* hexml_node_attributes(const document* d, const node* n, int* res)

180 return &d->attrs.attrs[n->attrs.start];

188 return &d->attrs.attrs[n->attrs.start];

181}

189}

182

190

191+

183attr* hexml_node_attribute(const document* d, const node* n, const char* s, int slen)

192attr* hexml_node_attribute(const document* d, const node* n, const char* s, int slen)

184{

193{

185 if (slen == -1) slen = (int) strlen(s);

194 if (slen == -1) slen = (int) strlen(s);

@@ -211,95 +220,33 @@ node* hexml_node_child(const document* d, const node* parent, const node* prev,

211/////////////////////////////////////////////////////////////////////

220/////////////////////////////////////////////////////////////////////

212// PARSING CODE

221// PARSING CODE

213

222

214−static inline node* node_alloc(node_buffer* b)

223+static inline void node_alloc(node_buffer* b, int ask)

215{

224{

216 int space = b->size - b->used_back - b->used_front;

225 int space = b->size - b->used_back - b->used_front;

217− if (space < 1)

226+ if (space >= ask) return;

218− {

219− int size2 = (b->size + 1000) * 2;

227+ int size2 = (b->size + 1000 + ask) * 2;

220− node* buf2 = malloc(size2 * sizeof(node));

228+ node* buf2 = malloc(size2 * sizeof(node));

221− assert(buf2);

229+ assert(buf2);

222− memcpy(buf2, b->nodes, b->used_front * sizeof(node));

230+ memcpy(buf2, b->nodes, b->used_front * sizeof(node));

223− memcpy(&buf2[size2 - b->used_back], &b->nodes[b->size - b->used_back], b->used_back * sizeof(node));

231+ memcpy(&buf2[size2 - b->used_back], &b->nodes[b->size - b->used_back], b->used_back * sizeof(node));

224− free(b->alloc);

232+ free(b->alloc);

225− b->size = size2;

233+ b->size = size2;

226− b->nodes = buf2;

234+ b->nodes = buf2;

227− b->alloc = buf2;

235+ b->alloc = buf2;

228− }

229− b->used_back++;

230− return &b->nodes[b->size - b->used_back];

231−}

232−

233−// buffer[from .. from+n] = reverse (buffer[from .. from+n])

234−// The ranges completely overlap

235−static inline void reverse(node* buffer, int from, int n)

236−{

237− for (int to = from + n - 1; to > from; from++, to--)

238− {

239− node temp = buffer[to];

240− buffer[to] = buffer[from];

241− buffer[from] = temp;

242− }

243−}

244−

245−// buffer[to .. to+n] = reverse (buffer[from .. from+n])

246−// The ranges may not overlap

247−static inline void memcpy_reverse(node* buffer, int from, int to, int n)

248−{

249− int end = from + n - 1;

250− for (int i = 0; i < n; i++)

251− buffer[to+i] = buffer[end-i];

252−}

253−

254−// buffer[to .. to+n] = reverse (buffer[from .. from+n])

255−// The ranges may overlap

256−static inline void memmove_reverse(node* buffer, int from, int to, int n)

257−{

258− assert(from >= to); // always the case in my usages

259− if (to + n < from)

260− memcpy_reverse(buffer, from, to, n);

261− else

262− {

263− int overlap = from - to;

264− memcpy_reverse(buffer, from, to + n - overlap, overlap);

265− reverse(buffer, to, n - overlap);

266− }

267−}

268−

269−static inline str node_commit(node_buffer* b)

270−{

271− // first search for an "open" node (nodes.length == -1)

272− int open;

273− for (open = b->size - b->used_back; open < b->size; open++)

274− {

275− if (b->nodes[open].nodes.length == -1)

276− break;

277− }

278−

279− int n = open - (b->size - b->used_back);

280− memmove_reverse(b->nodes, b->size - b->used_back, b->used_front, n);

281− b->used_back -= n;

282− b->used_front += n;

283− return start_length(b->used_front - n, n);

284}

236}

285

237

286−static inline attr* attr_alloc(attr_buffer* b)

238+static inline void attr_alloc(attr_buffer* b, int ask)

287{

239{

288− // Ensure there is at least one node left

289 int space = b->size - b->used;

240 int space = b->size - b->used;

290− if (space < 1)

241+ if (space >= ask) return;

291− {

292− int size2 = (b->size + 1000) * 2;

242+ int size2 = (b->size + 1000 + ask) * 2;

293− attr* buf2 = malloc(size2 * sizeof(attr));

243+ attr* buf2 = malloc(size2 * sizeof(attr));

294− assert(buf2);

244+ assert(buf2);

295− memcpy(buf2, b->attrs, b->used * sizeof(attr));

245+ memcpy(buf2, b->attrs, b->used * sizeof(attr));

296− free(b->alloc);

246+ free(b->alloc);

297− b->size = size2;

247+ b->size = size2;

298− b->attrs = buf2;

248+ b->attrs = buf2;

299− b->alloc = buf2;

249+ b->alloc = buf2;

300− }

301− b->used++;

302− return &b->attrs[b->used - 1];

303}

250}

304

251

305static void set_error(document* d, const char* msg)

252static void set_error(document* d, const char* msg)

@@ -316,49 +263,28 @@ static inline str gap(const char* ref, const char* start, const char* end)

316}

263}

317

264

318#define P_Abort(x) return x

265#define P_Abort(x) return x

319−#define P_Tag tag_start = p;

320#define P_NameStart name_start = p

266#define P_NameStart name_start = p

321#define P_NameEnd name_end = p

267#define P_NameEnd name_end = p

322−#define P_AttribsStart \

323− me = node_alloc(&d->nodes); \

324− me->attrs.start = d->attrs.used; \

325− me->name = gap(d->body, name_start, name_end);

326−#define P_AttribsEnd \

327− me->attrs = start_end(me->attrs.start, d->attrs.used);

328#define P_QuoteStart quote_start = p

268#define P_QuoteStart quote_start = p

329#define P_QuoteEnd \

269#define P_QuoteEnd \

270+ quote_end = p; \

330− attr* attr = attr_alloc(&d->attrs); \

271+ attr_alloc(&d->attrs, 1); \

331− attr->name = gap(d->body, name_start, name_end); \

272+ d->attrs.attrs[d->attrs.used].name = gap(d->body, name_start, name_end); \

332− attr->value = gap(d->body, quote_start, p);

273+ d->attrs.attrs[d->attrs.used].value = gap(d->body, quote_start, quote_end); \

274+ d->attrs.used++;

275+#define P_AttribsStart printf("AttribsStart %s\n", p)

276+#define P_AttribsEnd printf("AttribsEnd %s\n", p)

277+#define P_Tag tag_start = p

333−#define P_TagComment \

278+#define P_TagComment printf("TagComment %s\n", p)

334− // No action required - comments just flow as normal text

335−#define P_TagOpen \

279+#define P_TagOpen printf("TagOpen %s\n", p)

336− me->nodes.length = -1; \

337− me->inner = gap(d->body, p, p); \

338− me->outer = gap(d->body, tag_start, tag_start);

339−#define P_TagClose \

280+#define P_TagClose printf("TagClose %s\n", p)

340− str nodes = node_commit(&d->nodes); \

341− if (d->nodes.used_back == 0) \

342− return "Closing tag with no openning"; \

343− me = &d->nodes.nodes[d->nodes.size - d->nodes.used_back]; \

344− me->nodes = nodes; \

345− if (me->name.length != gap(d->body, name_start, name_end).length || \

346− memcmp(&d->body[me->name.start], name_start, me->name.length) != 0) \

347− return "Mismatch in closing tag"; \

348− me->inner = gap(d->body, &d->body[me->inner.start], tag_start); \

349− me->outer = gap(d->body, &d->body[me->outer.start], p);

350#define P_TagOpenClose \

281#define P_TagOpenClose \

351− me->nodes = start_end(0, 0); \

352− me->inner = gap(d->body, p, p); \

353− me->outer = gap(d->body, tag_start, p);

282+ d->nodes.nodes[d->nodes.used_front].outer = gap(d->body, tag_start, p); \

283+ printf("TagOpenClose %s\n", p)

354

284

355−// Given the parsed string, return either NULL (success) or an error message (failure)

356static const char* parser(const char* p, document* d)

285static const char* parser(const char* p, document* d)

357{

286{

358− const char *tag_start; // Where the tag starts [<foo

287+ const char *tag_start, *name_start, *name_end, *quote_start, *quote_end;

359− const char *name_start, *name_end; // Where a name is <[foo] or <foo [bar]=

360− const char *quote_start; // Where an attribute quote is <foo bar='[123'>

361− node* me; // The current node I'm working on

362# include "test.h"

288# include "test.h"

363 return NULL;

289 return NULL;

364}

290}

@@ -376,12 +302,14 @@ document* hexml_document_parse(const char* s, int slen)

376{

302{

377 if (slen == -1) slen = (int) strlen(s);

303 if (slen == -1) slen = (int) strlen(s);

378 assert(s[slen] == 0);

304 assert(s[slen] == 0);

305+ // init_parse_table();

379

306

380 buffer* buf = malloc(sizeof(buffer));

307 buffer* buf = malloc(sizeof(buffer));

381 assert(buf);

308 assert(buf);

382 document* d = &buf->document;

309 document* d = &buf->document;

383 d->body = s;

310 d->body = s;

384− d->body_len = slen;

311+ d->cursor = s;

312+ d->end = &s[slen];

385 d->error_message = NULL;

313 d->error_message = NULL;

386 d->attrs.size = 1000;

314 d->attrs.size = 1000;

387 d->attrs.used = 0;

315 d->attrs.used = 0;

@@ -402,70 +330,21 @@ document* hexml_document_parse(const char* s, int slen)

402 // because there is no guaranteed ordering between LHS and RHS evaluation

330 // because there is no guaranteed ordering between LHS and RHS evaluation

403 const char* res = parser(s, d);

331 const char* res = parser(s, d);

404 if (res != NULL)

332 if (res != NULL)

405− set_error(d, res);

333+ d->error_message = strdup(res);

406− else

407− {

408− d->nodes.nodes[0].nodes = node_commit(&d->nodes);

334+ // d->nodes.nodes[0].nodes = content;

409− if (d->nodes.used_back != 0)

410− d->error_message = strdup("used_back failure");

411− }

412 return d;

335 return d;

413}

336}

414

337

415−/////////////////////////////////////////////////////////////////////

416−// TEST HARNESS (temporary)

417−

418−#ifdef TEST

419−

420−static char* resolve(const document* d, str loc)

421−{

422− char* buf = malloc(loc.length + 3);

423− memcpy(&buf[1], &d->body[loc.start], loc.length);

424− buf[0] = '\"';

425− buf[loc.length+1] = '\"';

426− buf[loc.length+2] = 0;

427− return buf;

428−}

429−

430−static char* disp(str loc)

431−{

432− char* buf = malloc(100);

433− if (loc.length == 0)

434− strcpy(buf, "[]");

435− else

436− sprintf(buf, "[%i..%i]", loc.start, end(loc)-1);

437− return buf;

438−}

439−

440int main()

338int main()

441{

339{

442− setbuf(stdout, NULL);

443− const char* example = "<test foo='123 xyz' bar='t'><inner /> value</test>";

340+ const document* d = hexml_document_parse("<test foo='123 xyz'><inner /> value</test>", -1);

444− document* d = hexml_document_parse(example, -1);

445− if (d->error_message != NULL)

446− printf("Parse failure: %s\n", d->error_message);

447− else

448− {

449− char buf[1000];

341+ char buf[1000];

450− int len = hexml_node_render(d, hexml_document_node(d), buf, sizeof(buf));

342+ int len = hexml_node_render(d, hexml_document_node(d), buf, sizeof(buf));

451− buf[len] = 0;

343+ buf[len] = 0;

452− printf("Result = %s\n", buf);

344+ printf("Result = %s\n", buf);

453− printf("Used nodes = %i, attributes = %i\n", d->nodes.used_front, d->attrs.used);

454−

455− for (int i = 0; i < d->attrs.used; i++)

456− printf("Attr %i: %s=%s\n", i, resolve(d, d->attrs.attrs[i].name), resolve(d, d->attrs.attrs[i].value));

457− for (int i = 0; i < d->nodes.used_front; i++)

458− {

459− printf("Node %i: %s attrs=%s, nodes=%s\n", i, resolve(d, d->nodes.nodes[i].name), disp(d->nodes.nodes[i].attrs), disp(d->nodes.nodes[i].nodes));

460− printf(" inner %s\n outer %s\n", resolve(d, d->nodes.nodes[i].inner), resolve(d, d->nodes.nodes[i].outer));

461− }

462− }

463− hexml_document_free(d);

464− return 0;

345+ return 0;

465}

346}

466

347

467−#endif

468−

469/*

348/*

470void main()

349void main()

471{

350{

ghci.bat−1

@@ -1,2 +1 @@

1gcc -O2 -std=c99 -c cbits\hexml.c -o cbits\hexml.o -Wall -Wextra -Werror && ghci.exe cbits\hexml.o %*

2−rem gcc -O2 -std=c99 -c gen\test.c -o gen\test.o -Wall -Wextra -Werror && ghci.exe gen\test.o %*

hexml.cabal+3−4

@@ -1,20 +1,19 @@

1cabal-version: >= 1.18

2build-type: Simple

3name: hexml

4−version: 0.3.4

4+version: 0.3.3

5license: BSD3

6−x-license: BSD-3-Clause OR Apache-2.0

7license-file: LICENSE

6license-file: LICENSE

8category: XML

7category: XML

9author: Neil Mitchell <ndmitchell@gmail.com>

8author: Neil Mitchell <ndmitchell@gmail.com>

10maintainer: Neil Mitchell <ndmitchell@gmail.com>

9maintainer: Neil Mitchell <ndmitchell@gmail.com>

11−copyright: Neil Mitchell 2016-2023

10+copyright: Neil Mitchell 2018

12synopsis: XML subset DOM parser

11synopsis: XML subset DOM parser

13description:

12description:

14 An XML DOM-style parser, that only parses a subset of XML, but is designed to be fast.

13 An XML DOM-style parser, that only parses a subset of XML, but is designed to be fast.

15homepage: https://github.com/ndmitchell/hexml#readme

14homepage: https://github.com/ndmitchell/hexml#readme

16bug-reports: https://github.com/ndmitchell/hexml/issues

15bug-reports: https://github.com/ndmitchell/hexml/issues

17−tested-with: GHC==9.6, GHC==9.4, GHC==9.2, GHC==9.0, GHC==8.10, GHC==8.8

16+tested-with: GHC==8.2.1, GHC==8.0.2, GHC==7.10.3, GHC==7.8.4, GHC==7.6.3

18extra-doc-files:

17extra-doc-files:

19 README.md

18 README.md

20 CHANGES.txt

19 CHANGES.txt

src/Main.hs+4−4

@@ -44,12 +44,12 @@ main = do

44 attributes (head $ children doc) === [Attribute "id" "1", Attribute "extra" "2"]

45 map (`attributeBy` "id") (childrenBy doc "test") === map (fmap (Attribute "id")) [Just "1", Just "2", Just "4", Nothing]

47− Right _ <- pure $ parse $ "<test " <> BS.unwords [BS.pack $ "x" ++ show i ++ "='value'" | i <- [1..10000]] <> " />"

47+ Right _ <- return $ parse $ "<test " <> BS.unwords [BS.pack $ "x" ++ show i ++ "='value'" | i <- [1..10000]] <> " />"

48− Right _ <- pure $ parse $ BS.unlines $ replicate 10000 "<test x='value' />"

48+ Right _ <- return $ parse $ BS.unlines $ replicate 10000 "<test x='value' />"

50 let attrs = ["usd:jpy","test","extra","more","stuff","jpy:usd","xxx","xxxx"]

51− Right doc <- pure $ parse $ "<test " <> BS.unwords [x <> "='" <> x <> "'" | x <- attrs] <> ">middle</test>"

51+ Right doc <- return $ parse $ "<test " <> BS.unwords [x <> "='" <> x <> "'" | x <- attrs] <> ">middle</test>"

52− [c] <- pure $ childrenBy doc "test"

52+ [c] <- return $ childrenBy doc "test"

53 forM_ attrs $ \a -> attributeBy c a === Just (Attribute a a)

54 forM_ ["missing","gone","nothing"] $ \a -> attributeBy c a === Nothing

55 putStrLn "\nSuccess"

src/Text/XML/Hexml.hs+9−9

@@ -90,11 +90,11 @@ parse src = do

90 if err /= nullPtr then do

91 bs <- BS.packCString =<< hexml_document_error doc

92 hexml_document_free doc

93− pure $ Left bs

93+ return $ Left bs

94 else do

95 node <- hexml_document_node doc

96 doc <- newForeignPtr hexml_document_free_funptr doc

97− pure $ Right $ Node src0 doc node

97+ return $ Right $ Node src0 doc node

99-- | Given a node, rerender it to something with an equivalent parse tree.

100-- Mostly useful for debugging - if you want the real source document use 'outer' instead.

@@ -103,7 +103,7 @@ render (Node src doc n) = unsafePerformIO $ withForeignPtr doc $ \d -> do

103 i <- hexml_node_render d n nullPtr 0

104 res <- BS.create (fromIntegral i) $ \ptr -> void $ hexml_node_render d n (castPtr ptr) i

105 touchBS src

106− pure res

106+ return res

107

108applyStr :: BS.ByteString -> Str -> BS.ByteString

109applyStr bs Str{..} = BS.take (fromIntegral strLength) $ BS.drop (fromIntegral strStart) bs

@@ -118,7 +118,7 @@ attrPeek :: BS.ByteString -> ForeignPtr CDocument -> Ptr CAttr -> Attribute

118attrPeek src doc a = unsafePerformIO $ withForeignPtr doc $ \_ -> do

119 name <- applyStr src <$> peekElemOff (castPtr a) 0

120 val <- applyStr src <$> peekElemOff (castPtr a) 1

121− pure $ Attribute name val

121+ return $ Attribute name val

122

123-- | Get the name of a node, e.g. @\<test /\>@ produces @\"test\"@.

124name :: Node -> BS.ByteString

@@ -142,7 +142,7 @@ outer = nodeBS 2

142contents :: Node -> [Either BS.ByteString Node]

143contents n@(Node src _ _) = f (strStart inner) outers

144 where

145− f i [] = string i (strEnd inner)

145+ f i [] = string i (strEnd inner) ++ []

146 f i ((x, n):xs) = string i (strStart x) ++ Right n : f (strEnd x) xs

147

148 string start end | start == end = []

@@ -156,7 +156,7 @@ children (Node src doc n) = unsafePerformIO $ withForeignPtr doc $ \d ->

156 alloca $ \count -> do

157 res <- hexml_node_children d n count

158 count <- fromIntegral <$> peek count

159− pure [Node src doc $ plusPtr res $ i*szNode | i <- [0..count-1]]

159+ return [Node src doc $ plusPtr res $ i*szNode | i <- [0..count-1]]

160

161-- | Get the attributes of this node.

162attributes :: Node -> [Attribute]

@@ -164,7 +164,7 @@ attributes (Node src doc n) = unsafePerformIO $ withForeignPtr doc $ \d ->

164 alloca $ \count -> do

165 res <- hexml_node_attributes d n count

166 count <- fromIntegral <$> peek count

167− pure [attrPeek src doc $ plusPtr res $ i*szAttr | i <- [0..count-1]]

167+ return [attrPeek src doc $ plusPtr res $ i*szAttr | i <- [0..count-1]]

168

169-- | Get the direct children of this node which have a specific name.

170-- A more efficient version of:

@@ -177,7 +177,7 @@ childrenBy (Node src doc n) str = go nullPtr

177 BS.unsafeUseAsCStringLen str $ \(bs, len) -> do

178 r <- hexml_node_child d n old bs $ fromIntegral len

179 touchBS src

180− pure $ if r == nullPtr then [] else Node src doc r : go r

180+ return $ if r == nullPtr then [] else Node src doc r : go r

181

182-- | Get the first attribute of this node which has a specific name, if there is one.

183-- A more efficient version of:

@@ -188,7 +188,7 @@ attributeBy (Node src doc n) str = unsafePerformIO $ withForeignPtr doc $ \d ->

188 BS.unsafeUseAsCStringLen str $ \(bs, len) -> do

189 r <- hexml_node_attribute d n bs $ fromIntegral len

190 touchBS src

191− pure $ if r == nullPtr then Nothing else Just $ attrPeek src doc r

191+ return $ if r == nullPtr then Nothing else Just $ attrPeek src doc r

192

193-- | Find the starting location of a node, the @<@ character.

194-- The first character will be reported as @(line 1,column 1)@, because thats