kgsueme/doc/doc2haskell.xsl

<!DOCTYPE xsl:stylesheet>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

<xsl:output method="text" media-type="text/plain" encoding="utf-8"/>

<xsl:template match="/"><![CDATA[
-- This is an automatically generated file. 
-- This is an automatically generated file. 
-- This is an automatically generated file. 
-- This is an automatically generated file. 
-- This is an automatically generated file. 

-- See doc/protocol.xml and doc/doc2haskell.xsl

-- primitive enc/decoders

import Data.Word
import Control.Monad.State

hasData :: State [Word8] Bool
hasData = do
           xs <- get
           return $ not $ null xs

getU8 :: State [Word8] Int
getU8 = do
           (x:xs) <- get
           put xs
           return x

getU16 :: State [Word8] Int
getU16 = do
             a <- getU8
             b <- getU8
             return $ a + b * 256

decU64
decI8
decI16
decI32
decDATA

sub dec_STRING {
   $data =~ s/^((?:..)*?)(?:\x00\x00|\Z)//s;
   # use Encode...
   join "", map chr, unpack "v*", $1;
}

sub dec_CONSTANT {
   $_[0];
}

sub dec_password {
   dec_U64;
}

sub dec_HEX { # for debugging
   "HEX: " . unpack "H*", $data;#d#
}

#############################################################################

sub enc_U8 {
   $data .= pack "C", $_[0];
}

sub enc_U16 {
   $data .= pack "v", $_[0];
}

sub enc_U32 {
   $data .= pack "V", $_[0];
}

sub enc_U64 {
   enc_U32 $_[0] & 0xffffffff;
   enc_U32 +($_[0] >> 32) & 0xffffffff;
}

sub enc_I8 {
   $data .= pack "c", $_[0];
}

sub enc_I16 {
   enc_U16 unpack "S", pack "s", $_[0];
}

sub enc_I32 {
   enc_U32 unpack "I", pack "i", $_[0];
}

sub enc_DATA {
   # a dream!
   $data .= $_[0];
}

sub enc_STRING {
   # should use encode for speed and clarity ;)
   $data .= pack "v*", map ord, split //, $_[0];
}

sub enc_CONSTANT {
   # nop
}

sub enc_password {
   require Math::BigInt; # I insist on 32-bit-perl.. should use C
   # $hash must be 64 bit
   my $hash = new Math::BigInt;
   $hash = $hash * 1055 + ord for split //, $_[0];
   enc_U64 $hash;
}

sub enc_HEX {
   die "enc_HEX not defined for good";
}

]]>

#############################################################################
# types
<xsl:apply-templates select="descendant::type"/>

#############################################################################
# structures
<xsl:apply-templates select="descendant::struct"/>

#############################################################################
# "less" primitive types<![CDATA[

decTREE
encTREE

]]>

#############################################################################
# messages
<xsl:apply-templates select="descendant::message"/>
}

1;
</xsl:template>

<xsl:template match="type[@type = 'S']">
dec<xsl:value-of select="@name"/> :: State [Word8] [Char]
dec<xsl:value-of select="@name"/> = do
   -- decode UCS-2 string of length <xsl:value-of select="@length"/>
   -- the first 0 terminates the string, but not the field

enc<xsl:value-of select="@name"/> =
   -- likewise, encode as UCS-2, fill space with 0

</xsl:template>

<xsl:template match="type[@type = 'A']">
dec<xsl:value-of select="@name"/> :: State [Word8] [Char]
dec<xsl:value-of select="@name"/> = do
   -- decode ASCII string of length <xsl:value-of select="@length"/>
   -- the first 0 terminates the string, but not the field

enc<xsl:value-of select="@name"/> =
   -- likewise, encode as ASCII, fill space with 0

</xsl:template>

<xsl:template match="type[@multiplier]">
dec<xsl:value-of select="@name"/> = do
   n &lt;- dec<xsl:value-of select="@type"/>
   return n * (1 / <xsl:value-of select="@multiplier"/>)

enc<xsl:value-of select="@name"/> n =
   enc<xsl:value-of select="@type"/> $ n * <xsl:value-of select="@multiplier"/>

</xsl:template>

<xsl:template match="member[@array = 'yes']" mode="dec">
   $r->{<xsl:value-of select="@name"/>} = (my $array = []);
   while (length $data) {
      push @$array, dec_<xsl:value-of select="@type"/>
                        <xsl:text> </xsl:text>
                        <xsl:value-of select="@default"/>;
   }
</xsl:template>

<xsl:template match="member" mode="dec">
   <xsl:if test="@guard-cond">
      -- decode next only when <xsl:value-of select="@guard-member"/> <xsl:value-of select="@guard-cond"/> --
   </xsl:if>
   dec<xsl:value-of select="@type"/> -- default <xsl:value-of select="@default"/> --
</xsl:template>

<xsl:template match="member" mode="enc">
   enc<xsl:value-of select="@type"/> defined $_[0]{<xsl:value-of select="@name"/>} ? $_[0]{<xsl:value-of select="@name"/> s
   <xsl:text>} : (</xsl:text>
   <xsl:value-of select="@default"/>
   <xsl:text>);</xsl:text>
</xsl:template>

<xsl:template match="struct">
dec<xsl:value-of select="@name"/> = do
   <xsl:apply-templates select="member" mode="dec"/>
   <xsl:if test="@class">
   -- result has class <xsl:value-of select="@class"/> --
   </xsl:if>

enc<xsl:value-of select="@name"/> s =
   <xsl:apply-templates select="member" mode="enc"/>

</xsl:template>

<xsl:template match="message">
# <xsl:value-of select="@name"/>
dec<xsl:value-of select="@src"/>_<xsl:value-of select="@type"/> = do
   -- type "<xsl:value-of select="@name"/>" --
   <xsl:apply-templates select="member" mode="dec"/>

enc<xsl:value-of select="@src"/>_<xsl:value-of select="@name"/> =
   encU16 0x<xsl:value-of select="@type"/>
   <xsl:apply-templates select="member" mode="enc"/>

</xsl:template>

<xsl:template match="member">
   [<xsl:value-of select="@name"/>
   <xsl:text>=> "</xsl:text>
   <xsl:value-of select="@type"/>
   <xsl:text>", "</xsl:text>
   <xsl:value-of select="@default"/>
   <xsl:text>", "</xsl:text>
   <xsl:value-of select="@guard"/>
   <xsl:text>;"],</xsl:text>
</xsl:template>

<xsl:template match="text()">
</xsl:template>

</xsl:stylesheet>

Revision:	1.5
Committed:	Fri Jul 25 22:40:53 2003 UTC (20 years, 10 months ago) by pcg
Content type:	application/xml
Branch:	MAIN
Changes since 1.4:	+18 -23 lines
Log Message:	* empty log message *
#	User	Rev	Content
1	pcg	1.1	<!DOCTYPE xsl:stylesheet>
2			<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
3
4			<xsl:output method="text" media-type="text/plain" encoding="utf-8"/>
5
6			<xsl:template match="/"><![CDATA[
7			-- This is an automatically generated file.
8			-- This is an automatically generated file.
9			-- This is an automatically generated file.
10			-- This is an automatically generated file.
11			-- This is an automatically generated file.
12
13			-- See doc/protocol.xml and doc/doc2haskell.xsl
14
15			-- primitive enc/decoders
16
17	pcg	1.2	import Data.Word
18			import Control.Monad.State
19	pcg	1.1
20	pcg	1.4	hasData :: State [Word8] Bool
21			hasData = do
22			xs <- get
23			return $ not $ null xs
24
25	pcg	1.2	getU8 :: State [Word8] Int
26			getU8 = do
27			(x:xs) <- get
28			put xs
29			return x
30
31			getU16 :: State [Word8] Int
32			getU16 = do
33			a <- getU8
34			b <- getU8
35			return $ a + b * 256
36
37	pcg	1.3	decU64
38			decI8
39			decI16
40			decI32
41			decDATA
42	pcg	1.1
43			sub dec_STRING {
44			$data =~ s/^((?:..)*?)(?:\x00\x00\|\Z)//s;
45			# use Encode...
46			join "", map chr, unpack "v*", $1;
47			}
48
49			sub dec_CONSTANT {
50			$_[0];
51			}
52
53			sub dec_password {
54			dec_U64;
55			}
56
57			sub dec_HEX { # for debugging
58			"HEX: " . unpack "H*", $data;#d#
59			}
60
61			#############################################################################
62
63			sub enc_U8 {
64			$data .= pack "C", $_[0];
65			}
66
67			sub enc_U16 {
68			$data .= pack "v", $_[0];
69			}
70
71			sub enc_U32 {
72			$data .= pack "V", $_[0];
73			}
74
75			sub enc_U64 {
76			enc_U32 $_[0] & 0xffffffff;
77			enc_U32 +($_[0] >> 32) & 0xffffffff;
78			}
79
80			sub enc_I8 {
81			$data .= pack "c", $_[0];
82			}
83
84			sub enc_I16 {
85			enc_U16 unpack "S", pack "s", $_[0];
86			}
87
88			sub enc_I32 {
89			enc_U32 unpack "I", pack "i", $_[0];
90			}
91
92			sub enc_DATA {
93			# a dream!
94			$data .= $_[0];
95			}
96
97			sub enc_STRING {
98			# should use encode for speed and clarity ;)
99			$data .= pack "v*", map ord, split //, $_[0];
100			}
101
102			sub enc_CONSTANT {
103			# nop
104			}
105
106			sub enc_password {
107			require Math::BigInt; # I insist on 32-bit-perl.. should use C
108			# $hash must be 64 bit
109			my $hash = new Math::BigInt;
110			$hash = $hash * 1055 + ord for split //, $_[0];
111			enc_U64 $hash;
112			}
113
114			sub enc_HEX {
115			die "enc_HEX not defined for good";
116			}
117
118			]]>
119
120			#############################################################################
121			# types
122			<xsl:apply-templates select="descendant::type"/>
123
124			#############################################################################
125			# structures
126			<xsl:apply-templates select="descendant::struct"/>
127
128			#############################################################################
129			# "less" primitive types<![CDATA[
130
131	pcg	1.3	decTREE
132			encTREE
133
134	pcg	1.1	]]>
135
136			#############################################################################
137			# messages
138			<xsl:apply-templates select="descendant::message"/>
139			}
140
141			1;
142			</xsl:template>
143
144			<xsl:template match="type[@type = 'S']">
145	pcg	1.3	dec<xsl:value-of select="@name"/> :: State [Word8] [Char]
146			dec<xsl:value-of select="@name"/> = do
147			-- decode UCS-2 string of length <xsl:value-of select="@length"/>
148			-- the first 0 terminates the string, but not the field
149	pcg	1.1
150	pcg	1.3	enc<xsl:value-of select="@name"/> =
151			-- likewise, encode as UCS-2, fill space with 0
152	pcg	1.5
153	pcg	1.1	</xsl:template>
154
155			<xsl:template match="type[@type = 'A']">
156	pcg	1.3	dec<xsl:value-of select="@name"/> :: State [Word8] [Char]
157			dec<xsl:value-of select="@name"/> = do
158			-- decode ASCII string of length <xsl:value-of select="@length"/>
159			-- the first 0 terminates the string, but not the field
160	pcg	1.1
161	pcg	1.3	enc<xsl:value-of select="@name"/> =
162			-- likewise, encode as ASCII, fill space with 0
163	pcg	1.5
164	pcg	1.1	</xsl:template>
165
166			<xsl:template match="type[@multiplier]">
167	pcg	1.3	dec<xsl:value-of select="@name"/> = do
168			n <- dec<xsl:value-of select="@type"/>
169			return n * (1 / <xsl:value-of select="@multiplier"/>)
170	pcg	1.1
171	pcg	1.5	enc<xsl:value-of select="@name"/> n =
172			enc<xsl:value-of select="@type"/> $ n * <xsl:value-of select="@multiplier"/>
173
174	pcg	1.1	</xsl:template>
175
176			<xsl:template match="member[@array = 'yes']" mode="dec">
177			$r->{<xsl:value-of select="@name"/>} = (my $array = []);
178			while (length $data) {
179			push @$array, dec_<xsl:value-of select="@type"/>
180			<xsl:text> </xsl:text>
181			<xsl:value-of select="@default"/>;
182			}
183			</xsl:template>
184
185			<xsl:template match="member" mode="dec">
186			<xsl:if test="@guard-cond">
187	pcg	1.5	-- decode next only when <xsl:value-of select="@guard-member"/> <xsl:value-of select="@guard-cond"/> --
188			</xsl:if>
189	pcg	1.4	dec<xsl:value-of select="@type"/> -- default <xsl:value-of select="@default"/> --
190	pcg	1.1	</xsl:template>
191
192			<xsl:template match="member" mode="enc">
193	pcg	1.5	enc<xsl:value-of select="@type"/> defined $_[0]{<xsl:value-of select="@name"/>} ? $_[0]{<xsl:value-of select="@name"/> s
194	pcg	1.1	<xsl:text>} : (</xsl:text>
195			<xsl:value-of select="@default"/>
196			<xsl:text>);</xsl:text>
197			</xsl:template>
198
199			<xsl:template match="struct">
200	pcg	1.5	dec<xsl:value-of select="@name"/> = do
201	pcg	1.1	<xsl:apply-templates select="member" mode="dec"/>
202			<xsl:if test="@class">
203	pcg	1.5	-- result has class <xsl:value-of select="@class"/> --
204	pcg	1.1	</xsl:if>
205
206	pcg	1.5	enc<xsl:value-of select="@name"/> s =
207	pcg	1.1	<xsl:apply-templates select="member" mode="enc"/>
208	pcg	1.5
209	pcg	1.1	</xsl:template>
210
211			<xsl:template match="message">
212			# <xsl:value-of select="@name"/>
213	pcg	1.5	dec<xsl:value-of select="@src"/>_<xsl:value-of select="@type"/> = do
214			-- type "<xsl:value-of select="@name"/>" --
215	pcg	1.1	<xsl:apply-templates select="member" mode="dec"/>
216	pcg	1.5
217			enc<xsl:value-of select="@src"/>_<xsl:value-of select="@name"/> =
218			encU16 0x<xsl:value-of select="@type"/>
219	pcg	1.1	<xsl:apply-templates select="member" mode="enc"/>
220	pcg	1.5
221	pcg	1.1	</xsl:template>
222
223			<xsl:template match="member">
224			[<xsl:value-of select="@name"/>
225			<xsl:text>=> "</xsl:text>
226			<xsl:value-of select="@type"/>
227			<xsl:text>", "</xsl:text>
228			<xsl:value-of select="@default"/>
229			<xsl:text>", "</xsl:text>
230			<xsl:value-of select="@guard"/>
231			<xsl:text>;"],</xsl:text>
232			</xsl:template>
233
234			<xsl:template match="text()">
235			</xsl:template>
236
237			</xsl:stylesheet>
238