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

module KGSProtocoll where
import Numeric
import Data.Word
import Control.Monad.State

type U8  = Int
type U16 = Int
type U32 = Word64
type U64 = Word64
type I8  = Int
type I16 = Int
type I32 = Word64 -- elmex? signed 32 bit
type I64 = Word64 -- elmex? likewise

data DecState = DecState { data :: [Word8] }

-- type DecS a = State DecState a
type DecS a = StateT DecState IO a -- for dec_HEX

hasData :: DecS Bool
hasData = do
           xs <- get
           return $ not $ null xs

dec_U8 :: Word8
dec_U8 =
  do (x:xs) <- get
     put xs 
     return x

dec_U16 :: DecS Word16
dec_U16 =
 do a <- dec_U8
    b <- dec_U8
    return $ (fromIntegral a :: Word16) + (fromIntegral b :: Word16) * 256


dec_U64 :: DecS Word64
dec_U64 =
  do a1 <- dec_U16
     a2 <- dec_U16
     a3 <- dec_U16
     a4 <- dec_U16
     return $   (fI a4) `shiftL` 48
              + (fI a3) `shiftL` 32
              + (fI a2) `shiftL` 16
              + (fI a1)
     where fI a = fromIntegral a :: Word64


dec_I8 :: DecS Int8
dec_I8 =
  do w8 <- dec_U8
     return $ fromIntegral w8 :: Int8

dec_I16 :: DecS Int16
dec_I16 =
  do w16 <- dec_U16
     return $ fromIntegral w16 :: Int16

dec_I32 :: DecS Int32
dec_I32 =
  do w16_1 <- dec_U16
     w16_2 <- dec_U16
     return $   (fI w16_2) `shiftL` 16
              + (fI w16_1)
     where fI a = fromIntegral a :: Int32

dec_DATA :: DecS [Word8]
dec_DATA =
  do da <- get
     put []
     return da

dec_STRING :: DecS [Word16]
dec_STRING =
  do c <- dec_U16
     if c == 0 then do return []
     else return (c:dec_STRING)

{-  do da <- get
     let (str,rest) = mkstr da
     where 
       mkstr str [] =
         (reverse str,[])
       mkstr str (0:rest) =
         (reverse str, rest)
       mkstr str (c:rest) =
         mkstr ((toEnum (fromIntegral c :: Int)):str) rest -}

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

dec_CONSTANT :: DecS a
dec_CONSTANT x = x

type Password = Word64

dec_password :: DecS Password
dec_password = dec_U64

dec_HEX :: DecS ()
dec_HEX =
  do da <- get
     putStr "HEX: "
     putStrLn $ (dec_data da) ""
     where dec_data (x:xs) = 
             ((drop 2) . showHex x . (':':)) . (dec_data xs)
           dec_data []     = (\_ -> "")

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

enc_U8 :: Word8 -> DecS ()
enc_U8 a = 
  do x <- get
     put (a:x)
     return ()

enc_U16 :: Word16 -> DecS ()
enc_U16 a =
  do x <- get
     let b1 = fromIntegral (a `shiftR` 8) :: Word8
         b2 = fromIntegral a :: Word8
     put (b1:b2:x)

enc_U32 :: Word32 -> DecS ()
enc_U32 a =
  let b1 = fromIntegral (a `shiftR` 16) :: Word16
      b2 = fromIntegral a :: Word16
   enc_U16 b2
   enc_U16 b1

enc_U64 :: Word64 -> DecS ()
enc_U64 a =
  let b1 = fromIntegral (a `shiftR` 48) :: Word16
      b2 = fromIntegral (a `shiftR` 32) :: Word16
      b3 = fromIntegral (a `shiftR` 16) :: Word16
      b4 = fromIntegral a :: Word16
   enc_U16 b4
   enc_U16 b3
   enc_U16 b2
   enc_U16 b1

enc_I8 :: Int8 -> DecS ()
enc_I8 a =
  enc_U8 (fromIntegral a :: Word8)

enc_I16 :: Int16 -> DecS ()
enc_I16 a =
  let b1 = fromIntegral (a `shiftR` 8) :: Word8
      b2 = fromIntegral a :: Word8
  enc_U8 b2
  enc_U8 b1
 
enc_I32 :: Int32 -> DecS ()
enc_I32 a =
  let 
      b1 = fromIntegral (a `shiftR` 16) :: Word16
      b2 = fromIntegral a :: Word16
  enc_U16 b2
  enc_U16 b1

enc_DATA :: [Word8] -> DecS ()
enc_DATA d =
  do x <- get 
     put $ (reverse d) ++ x

enc_STRING :: [Word16] -> DecS ()
enc_STRING (s:ss) =
  do enc_U16 s
     enc_STRING ss

{-  do let mstr = reverse s
         putall (u:ls) =
           do enc_U8 u
              putall ls
         putall [] = return ()
      putall mstr
      enc_U8 0 -}

enc_CONSTANT :: a -> DecS ()
enc_CONSTANT _ = return ()

enc_password :: Password -> DecS ()
enc_password (p:ps) =
 (1055 * (enc_password ps)) + (fromEnum p)

{- marc???
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;
}
-}

]]>

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

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

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

dec_TREE
enc_TREE

]]>

#############################################################################
# messages
data KGS_server_msg = 
  KGS_server_msg_null
<xsl:for-each select="descendant::message[@src='server']">
  | KGS_server_<xsl:value-of select="@name"/> {
<xsl:apply-templates select="member" mode="decl"/>
  <xsl:text>    }</xsl:text>
</xsl:for-each>

data KGS_client_msg =
  KGS_server_msg_null
<xsl:for-each select="descendant::message[@src='client']">
  | KGS_client_<xsl:value-of select="@name"/> {
<xsl:apply-templates select="member" mode="decl"/>
  <xsl:text>    }</xsl:text>
</xsl:for-each>

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

1;
</xsl:template>

<xsl:template match="type[@type = 'S']">
type <xsl:value-of select="@name"/> = String

-- decode UCS-2 string of length <xsl:value-of select="@length"/>
-- the first 0 terminates the string, but not the field
dec_<xsl:value-of select="@name"/> :: DecS String
dec_<xsl:value-of select="@name"/> = 
  do getS <xsl:value-of select="@length"/>
  where 
--    getS ls 0 = reverse ls
    getS ls 0 = reverse (map (\c -> toEnum (fromIntegral c :: Int)) ls)
    getS ls n = dec_U8 >>=\c getS (c:[]) (n-1)

-- likewise, encode as UCS-2, fill space with 0
enc_<xsl:value-of select="@name"/> :: String -> DecS ()
enc_<xsl:value-of select="@name"/> str = 
  do let rlen = (length str) - <xsl:value-of select="@length"/>
     putS str
     putN rlen
  where
    putN 0      = return ()
    putN n      = enc_U8 0 n-1
    putS []     = return ()
    putS (c:cs) = do enc_U8 c
                     putS cs
</xsl:template>

<xsl:template match="type[@type = 'A']">
type <xsl:value-of select="@name"/> = String

-- decode ASCII string of length <xsl:value-of select="@length"/>
-- the first 0 terminates the string, but not the field
dec_<xsl:value-of select="@name"/> :: DecS String
dec_<xsl:value-of select="@name"/> = 
  do getS <xsl:value-of select="@length"/>
  where 
    getS ls 0 = reverse (map (\c -> toEnum (fromIntegral c :: Int)) ls)
--    getS (0:ls) n = getS (0:ls) (n-1)
    getS ls n = dec_U8 >>=\c getS (c:[]) (n-1)

-- likewise, encode as ASCII, fill space with 0
enc_<xsl:value-of select="@name"/> :: String -> DecS ()
enc_<xsl:value-of select="@name"/> str = 
  do let rlen = (length str) - <xsl:value-of select="@length"/>
     putS str
     putN rlen
  where
    putN 0      = return ()
    putN n      = enc_U8 0 n-1
    putS []     = return ()
    putS (c:cs) = do enc_U8 c
                     putS cs
</xsl:template>

<xsl:template match="type[@multiplier]">
type <xsl:value-of select="@name"/> = Float

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:text>
</xsl:text>
</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">
      <xsl:text>   if </xsl:text><xsl:value-of select="@guard-member"/><xsl:text> </xsl:text> <xsl:value-of select="@guard-cond"/> then do
      </xsl:if>
   <xsl:text>   </xsl:text><xsl:value-of select="@name"/> &lt;- dec_<xsl:value-of select="@type"/>
<xsl:text>
</xsl:text>
</xsl:template>

<xsl:template match="member" mode="enc">
   <xsl:text>   enc_</xsl:text><xsl:value-of select="@type"/> $ <xsl:value-of select="@name"/> s
</xsl:template>

<xsl:template match="member" mode="decl">
   <xsl:text>      </xsl:text><xsl:value-of select="@name"/>:   !<xsl:value-of select="@type"/>
<xsl:text>
</xsl:text>
</xsl:template>

<xsl:template match="struct">
data KGS_<xsl:value-of select="@name"/> = KGS_<xsl:value-of select="@name"/>
    {
<xsl:apply-templates select="member" mode="decl"/>
    }

dec_<xsl:value-of select="@name"/> = do
<xsl:apply-templates select="member" mode="dec"/>
   return KGS_<xsl:value-of select="@name"/><xsl:for-each select="member"><xsl:text> </xsl:text><xsl:value-of select="@name"/></xsl:for-each>

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

<xsl:template match="message">
-- <xsl:value-of select="@name"/>
dec_<xsl:value-of select="@src"/>_<xsl:value-of select="@type"/> = do
<xsl:apply-templates select="member" mode="dec"/>
   return KGS_<xsl:value-of select="@name"/><xsl:for-each select="member"><xsl:text> </xsl:text><xsl:value-of select="@name"/></xsl:for-each>

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

</xsl:template>

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

</xsl:stylesheet>

Revision:	1.13
Committed:	Tue Jul 29 03:29:51 2003 UTC (20 years, 10 months ago) by pcg
Content type:	application/xml
Branch:	MAIN
Changes since 1.12:	+102 -74 lines
Log Message:	* empty log message *
#	User	Rev	Content
1	pcg	1.13	<!DOCTYPE xsl:stylesheet>
2	pcg	1.1	<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	elmex	1.9	module KGSProtocoll where
18			import Numeric
19	pcg	1.2	import Data.Word
20			import Control.Monad.State
21	pcg	1.1
22	pcg	1.13	type U8 = Int
23			type U16 = Int
24			type U32 = Word64
25			type U64 = Word64
26			type I8 = Int
27			type I16 = Int
28			type I32 = Word64 -- elmex? signed 32 bit
29			type I64 = Word64 -- elmex? likewise
30
31	elmex	1.9	data DecState = DecState { data :: [Word8] }
32
33			-- type DecS a = State DecState a
34			type DecS a = StateT DecState IO a -- for dec_HEX
35
36			hasData :: DecS Bool
37	pcg	1.4	hasData = do
38			xs <- get
39			return $ not $ null xs
40
41	pcg	1.13	dec_U8 :: Word8
42			dec_U8 =
43	elmex	1.9	do (x:xs) <- get
44			put xs
45			return x
46
47	pcg	1.13	dec_U16 :: DecS Word16
48			dec_U16 =
49			do a <- dec_U8
50			b <- dec_U8
51	elmex	1.9	return $ (fromIntegral a :: Word16) + (fromIntegral b :: Word16) * 256
52
53
54			dec_U64 :: DecS Word64
55			dec_U64 =
56	pcg	1.13	do a1 <- dec_U16
57			a2 <- dec_U16
58			a3 <- dec_U16
59			a4 <- dec_U16
60	pcg	1.11	return $ (fI a4) `shiftL` 48
61			+ (fI a3) `shiftL` 32
62			+ (fI a2) `shiftL` 16
63			+ (fI a1)
64	elmex	1.9	where fI a = fromIntegral a :: Word64
65
66
67			dec_I8 :: DecS Int8
68			dec_I8 =
69	pcg	1.13	do w8 <- dec_U8
70	elmex	1.9	return $ fromIntegral w8 :: Int8
71
72			dec_I16 :: DecS Int16
73			dec_I16 =
74	pcg	1.13	do w16 <- dec_U16
75	elmex	1.9	return $ fromIntegral w16 :: Int16
76
77			dec_I32 :: DecS Int32
78			dec_I32 =
79	pcg	1.13	do w16_1 <- dec_U16
80			w16_2 <- dec_U16
81	pcg	1.11	return $ (fI w16_2) `shiftL` 16
82			+ (fI w16_1)
83	elmex	1.9	where fI a = fromIntegral a :: Int32
84
85			dec_DATA :: DecS [Word8]
86			dec_DATA =
87			do da <- get
88			put []
89			return da
90
91	elmex	1.12	dec_STRING :: DecS [Word16]
92	elmex	1.9	dec_STRING =
93	pcg	1.13	do c <- dec_U16
94	elmex	1.12	if c == 0 then do return []
95			else return (c:dec_STRING)
96
97			{- do da <- get
98	elmex	1.9	let (str,rest) = mkstr da
99			where
100			mkstr str [] =
101			(reverse str,[])
102			mkstr str (0:rest) =
103			(reverse str, rest)
104			mkstr str (c:rest) =
105	elmex	1.12	mkstr ((toEnum (fromIntegral c :: Int)):str) rest -}
106	pcg	1.1
107	elmex	1.9	{-
108	pcg	1.1	sub dec_STRING {
109			$data =~ s/^((?:..)*?)(?:\x00\x00\|\Z)//s;
110			# use Encode...
111	elmex	1.9	join "", map chr, unpack "v*", $1; -- marc ???
112			}
113			-}
114
115			dec_CONSTANT :: DecS a
116			dec_CONSTANT x = x
117
118			type Password = Word64
119
120			dec_password :: DecS Password
121			dec_password = dec_U64
122
123			dec_HEX :: DecS ()
124			dec_HEX =
125			do da <- get
126			putStr "HEX: "
127			putStrLn $ (dec_data da) ""
128			where dec_data (x:xs) =
129			((drop 2) . showHex x . (':':)) . (dec_data xs)
130			dec_data [] = (\_ -> "")
131	pcg	1.1
132			#############################################################################
133
134	pcg	1.13	enc_U8 :: Word8 -> DecS ()
135			enc_U8 a =
136	elmex	1.9	do x <- get
137			put (a:x)
138			return ()
139
140	pcg	1.13	enc_U16 :: Word16 -> DecS ()
141			enc_U16 a =
142	elmex	1.9	do x <- get
143			let b1 = fromIntegral (a `shiftR` 8) :: Word8
144			b2 = fromIntegral a :: Word8
145	pcg	1.11	put (b1:b2:x)
146	elmex	1.9
147			enc_U32 :: Word32 -> DecS ()
148			enc_U32 a =
149			let b1 = fromIntegral (a `shiftR` 16) :: Word16
150			b2 = fromIntegral a :: Word16
151	pcg	1.13	enc_U16 b2
152			enc_U16 b1
153	elmex	1.9
154			enc_U64 :: Word64 -> DecS ()
155			enc_U64 a =
156			let b1 = fromIntegral (a `shiftR` 48) :: Word16
157			b2 = fromIntegral (a `shiftR` 32) :: Word16
158			b3 = fromIntegral (a `shiftR` 16) :: Word16
159			b4 = fromIntegral a :: Word16
160	pcg	1.13	enc_U16 b4
161			enc_U16 b3
162			enc_U16 b2
163			enc_U16 b1
164	elmex	1.9
165			enc_I8 :: Int8 -> DecS ()
166			enc_I8 a =
167	pcg	1.13	enc_U8 (fromIntegral a :: Word8)
168	elmex	1.9
169			enc_I16 :: Int16 -> DecS ()
170			enc_I16 a =
171			let b1 = fromIntegral (a `shiftR` 8) :: Word8
172			b2 = fromIntegral a :: Word8
173	pcg	1.13	enc_U8 b2
174			enc_U8 b1
175	elmex	1.9
176			enc_I32 :: Int32 -> DecS ()
177			enc_I32 a =
178			let
179			b1 = fromIntegral (a `shiftR` 16) :: Word16
180			b2 = fromIntegral a :: Word16
181	pcg	1.13	enc_U16 b2
182			enc_U16 b1
183	elmex	1.9
184			enc_DATA :: [Word8] -> DecS ()
185			enc_DATA d =
186			do x <- get
187			put $ (reverse d) ++ x
188
189	elmex	1.12	enc_STRING :: [Word16] -> DecS ()
190			enc_STRING (s:ss) =
191	pcg	1.13	do enc_U16 s
192	elmex	1.12	enc_STRING ss
193
194			{- do let mstr = reverse s
195	elmex	1.9	putall (u:ls) =
196	pcg	1.13	do enc_U8 u
197	elmex	1.9	putall ls
198			putall [] = return ()
199			putall mstr
200	pcg	1.13	enc_U8 0 -}
201	elmex	1.9
202			enc_CONSTANT :: a -> DecS ()
203			enc_CONSTANT _ = return ()
204
205			enc_password :: Password -> DecS ()
206	elmex	1.12	enc_password (p:ps) =
207			(1055 * (enc_password ps)) + (fromEnum p)
208	pcg	1.1
209	elmex	1.9	{- marc???
210	pcg	1.1	sub enc_password {
211			require Math::BigInt; # I insist on 32-bit-perl.. should use C
212			# $hash must be 64 bit
213			my $hash = new Math::BigInt;
214			$hash = $hash * 1055 + ord for split //, $_[0];
215			enc_U64 $hash;
216			}
217	elmex	1.9	-}
218	pcg	1.1
219			]]>
220
221			#############################################################################
222			# types
223			<xsl:apply-templates select="descendant::type"/>
224
225			#############################################################################
226			# structures
227			<xsl:apply-templates select="descendant::struct"/>
228
229			#############################################################################
230			# "less" primitive types<![CDATA[
231
232	pcg	1.6	dec_TREE
233			enc_TREE
234	pcg	1.3
235	pcg	1.1	]]>
236
237			#############################################################################
238			# messages
239	pcg	1.13	data KGS_server_msg =
240			KGS_server_msg_null
241			<xsl:for-each select="descendant::message[@src='server']">
242			\| KGS_server_<xsl:value-of select="@name"/> {
243			<xsl:apply-templates select="member" mode="decl"/>
244			<xsl:text> }</xsl:text>
245			</xsl:for-each>
246
247			data KGS_client_msg =
248			KGS_server_msg_null
249			<xsl:for-each select="descendant::message[@src='client']">
250			\| KGS_client_<xsl:value-of select="@name"/> {
251			<xsl:apply-templates select="member" mode="decl"/>
252			<xsl:text> }</xsl:text>
253			</xsl:for-each>
254
255	pcg	1.1	<xsl:apply-templates select="descendant::message"/>
256			}
257
258			1;
259			</xsl:template>
260
261			<xsl:template match="type[@type = 'S']">
262	pcg	1.13	type <xsl:value-of select="@name"/> = String
263
264	elmex	1.10	-- decode UCS-2 string of length <xsl:value-of select="@length"/>
265			-- the first 0 terminates the string, but not the field
266			dec_<xsl:value-of select="@name"/> :: DecS String
267			dec_<xsl:value-of select="@name"/> =
268			do getS <xsl:value-of select="@length"/>
269			where
270			-- getS ls 0 = reverse ls
271			getS ls 0 = reverse (map (\c -> toEnum (fromIntegral c :: Int)) ls)
272	pcg	1.13	getS ls n = dec_U8 >>=\c getS (c:[]) (n-1)
273	elmex	1.10
274			-- likewise, encode as UCS-2, fill space with 0
275			enc_<xsl:value-of select="@name"/> :: String -> DecS ()
276			enc_<xsl:value-of select="@name"/> str =
277			do let rlen = (length str) - <xsl:value-of select="@length"/>
278			putS str
279			putN rlen
280			where
281			putN 0 = return ()
282	pcg	1.13	putN n = enc_U8 0 n-1
283	elmex	1.10	putS [] = return ()
284	pcg	1.13	putS (c:cs) = do enc_U8 c
285	elmex	1.10	putS cs
286	pcg	1.1	</xsl:template>
287
288			<xsl:template match="type[@type = 'A']">
289	pcg	1.13	type <xsl:value-of select="@name"/> = String
290
291	elmex	1.10	-- decode ASCII string of length <xsl:value-of select="@length"/>
292			-- the first 0 terminates the string, but not the field
293			dec_<xsl:value-of select="@name"/> :: DecS String
294			dec_<xsl:value-of select="@name"/> =
295			do getS <xsl:value-of select="@length"/>
296			where
297			getS ls 0 = reverse (map (\c -> toEnum (fromIntegral c :: Int)) ls)
298			-- getS (0:ls) n = getS (0:ls) (n-1)
299	pcg	1.13	getS ls n = dec_U8 >>=\c getS (c:[]) (n-1)
300	elmex	1.10
301			-- likewise, encode as ASCII, fill space with 0
302			enc_<xsl:value-of select="@name"/> :: String -> DecS ()
303			enc_<xsl:value-of select="@name"/> str =
304			do let rlen = (length str) - <xsl:value-of select="@length"/>
305			putS str
306			putN rlen
307			where
308			putN 0 = return ()
309	pcg	1.13	putN n = enc_U8 0 n-1
310	elmex	1.10	putS [] = return ()
311	pcg	1.13	putS (c:cs) = do enc_U8 c
312	elmex	1.10	putS cs
313	pcg	1.1	</xsl:template>
314
315			<xsl:template match="type[@multiplier]">
316	pcg	1.13	type <xsl:value-of select="@name"/> = Float
317
318	pcg	1.6	dec_<xsl:value-of select="@name"/> = do
319	pcg	1.13	n <- dec_<xsl:value-of select="@type"/>
320	elmex	1.10	return $ n * (1 / <xsl:value-of select="@multiplier"/>)
321	pcg	1.1
322	pcg	1.6	enc_<xsl:value-of select="@name"/> n =
323	pcg	1.13	enc_<xsl:value-of select="@type"/> $ n * <xsl:value-of select="@multiplier"/>
324
325			<xsl:text>
326			</xsl:text>
327	pcg	1.1	</xsl:template>
328
329			<xsl:template match="member[@array = 'yes']" mode="dec">
330			$r->{<xsl:value-of select="@name"/>} = (my $array = []);
331			while (length $data) {
332			push @$array, dec_<xsl:value-of select="@type"/>
333			<xsl:text> </xsl:text>
334			<xsl:value-of select="@default"/>;
335			}
336			</xsl:template>
337
338			<xsl:template match="member" mode="dec">
339			<xsl:if test="@guard-cond">
340	pcg	1.13	<xsl:text> if </xsl:text><xsl:value-of select="@guard-member"/><xsl:text> </xsl:text> <xsl:value-of select="@guard-cond"/> then do
341			</xsl:if>
342			<xsl:text> </xsl:text><xsl:value-of select="@name"/> <- dec_<xsl:value-of select="@type"/>
343			<xsl:text>
344			</xsl:text>
345	pcg	1.1	</xsl:template>
346
347			<xsl:template match="member" mode="enc">
348	pcg	1.13	<xsl:text> enc_</xsl:text><xsl:value-of select="@type"/> $ <xsl:value-of select="@name"/> s
349			</xsl:template>
350
351			<xsl:template match="member" mode="decl">
352			<xsl:text> </xsl:text><xsl:value-of select="@name"/>: !<xsl:value-of select="@type"/>
353			<xsl:text>
354			</xsl:text>
355	pcg	1.1	</xsl:template>
356
357			<xsl:template match="struct">
358	pcg	1.13	data KGS_<xsl:value-of select="@name"/> = KGS_<xsl:value-of select="@name"/>
359			{
360			<xsl:apply-templates select="member" mode="decl"/>
361			}
362
363	pcg	1.6	dec_<xsl:value-of select="@name"/> = do
364	pcg	1.13	<xsl:apply-templates select="member" mode="dec"/>
365			return KGS_<xsl:value-of select="@name"/><xsl:for-each select="member"><xsl:text> </xsl:text><xsl:value-of select="@name"/></xsl:for-each>
366	pcg	1.1
367	pcg	1.6	enc_<xsl:value-of select="@name"/> s =
368	pcg	1.13	<xsl:apply-templates select="member" mode="enc"/>
369			<xsl:text>
370			</xsl:text>
371	pcg	1.1	</xsl:template>
372
373			<xsl:template match="message">
374	pcg	1.6	-- <xsl:value-of select="@name"/>
375			dec_<xsl:value-of select="@src"/>_<xsl:value-of select="@type"/> = do
376	pcg	1.13	<xsl:apply-templates select="member" mode="dec"/>
377			return KGS_<xsl:value-of select="@name"/><xsl:for-each select="member"><xsl:text> </xsl:text><xsl:value-of select="@name"/></xsl:for-each>
378	pcg	1.5
379	pcg	1.6	enc_<xsl:value-of select="@src"/>_<xsl:value-of select="@name"/> =
380	pcg	1.13	enc_U16 0x<xsl:value-of select="@type"/>
381			<xsl:apply-templates select="member" mode="enc"/>
382	pcg	1.5
383	pcg	1.1	</xsl:template>
384
385			<xsl:template match="text()">
386			</xsl:template>
387
388			</xsl:stylesheet>
389