Web Replay: code generator should take supplemental specifications and allow cross...
[WebKit-https.git] / Source / JavaScriptCore / replay / scripts / CodeGeneratorReplayInputsTemplates.py
1 #!/usr/bin/env python
2 # Copyright (c) 2011 Google Inc. All rights reserved.
3 # Copyright (c) 2012 Intel Corporation. All rights reserved.
4 # Copyright (c) 2013, 2014 Apple Inc. All rights reserved.
5 #
6 # Redistribution and use in source and binary forms, with or without
7 # modification, are permitted provided that the following conditions are
8 # met:
9 #
10 #     * Redistributions of source code must retain the above copyright
11 # notice, this list of conditions and the following disclaimer.
12 #     * Redistributions in binary form must reproduce the above
13 # copyright notice, this list of conditions and the following disclaimer
14 # in the documentation and/or other materials provided with the
15 # distribution.
16 #     * Neither the name of Google Inc. nor the names of its
17 # contributors may be used to endorse or promote products derived from
18 # this software without specific prior written permission.
19 #
20 # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
21 # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
22 # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
23 # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
24 # OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
25 # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
26 # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
27 # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
28 # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
29 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
30 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31
32
33 # Generator templates, which can be filled with string.Template.
34 # Following are classes that fill the templates from the typechecked model.
35
36 class Templates:
37     CopyrightBlock = (
38     """/*
39  * Copyright (C) 2014 Apple Inc. All rights reserved.
40  *
41  * Redistribution and use in source and binary forms, with or without
42  * modification, are permitted provided that the following conditions
43  * are met:
44  *
45  * 1.  Redistributions of source code must retain the above copyright
46  *     notice, this list of conditions and the following disclaimer.
47  * 2.  Redistributions in binary form must reproduce the above copyright
48  *     notice, this list of conditions and the following disclaimer in the
49  *     documentation and/or other materials provided with the distribution.
50  *
51  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
52  * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
53  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
54  * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
55  * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
56  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
57  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
58  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
59  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
60  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
61  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
62  */
63
64 // DO NOT EDIT THIS FILE. It is automatically generated from ${inputFilename}
65 // by the script: JavaScriptCore/replay/scripts/CodeGeneratorReplayInputs.py""")
66
67     HeaderSkeleton = (
68     """${licenseBlock}
69
70 #ifndef ${headerGuard}
71 #define ${headerGuard}
72
73 #if ${guardCondition}
74 ${includes}
75
76 ${typeForwardDeclarations}
77
78 namespace ${inputsNamespace} {
79 ${inputForwardDeclarations}
80 } // namespace ${inputsNamespace}
81
82 namespace ${traitsNamespace} {
83 ${inputTraitDeclarations}
84 ${enumTraitDeclarations}
85 } // namespace ${traitsNamespace}
86
87 namespace ${inputsNamespace} {
88 ${inputClassDeclarations}
89 } // namespace ${inputsNamespace}
90
91 ${inputTypeTraitDeclarations}
92
93 ${forEachMacro}
94
95 #endif // ${guardCondition}
96
97 #endif // ${filename}_h
98 """)
99
100     InputTraitsDeclaration = (
101     """template<> ${structOrClass} InputTraits<${qualifiedInputName}> {
102     static InputQueue queue() { return InputQueue::${queueType}; }
103     static const String& type();
104
105     static void encode(JSC::EncodedValue&, const ${qualifiedInputName}&);
106     static bool decode(JSC::EncodedValue&, std::unique_ptr<${qualifiedInputName}>&);
107 };""")
108
109     InputTypeTraitsDeclaration = (
110     """SPECIALIZE_TYPE_TRAITS_BEGIN(${qualifiedInputName})
111     static bool isType(const NondeterministicInputBase& input) { return input.type() == InputTraits<${qualifiedInputName}>::type(); }
112 SPECIALIZE_TYPE_TRAITS_END()""")
113
114     EnumTraitDeclaration = (
115     """template<> ${structOrClass} EncodingTraits<${encodingTypeArgument}> {
116     typedef ${enumType} DecodedType;
117
118     static EncodedValue encodeValue(const ${enumType}& value);
119     static bool decodeValue(EncodedValue&, ${enumType}& value);
120 };""")
121
122     EnumClassTraitDeclaration = (
123     """template<> ${structOrClass} EncodingTraits<${encodingTypeArgument}> {
124     typedef ${enumType} DecodedType;
125
126     static EncodedValue encodeValue(const ${enumType}& value);
127     static bool decodeValue(EncodedValue&, ${enumType}& value);
128 };""")
129
130     InputClassDeclaration = (
131     """class ${inputName} : public ${baseClass} {
132 public:
133 ${inputConstructor}
134 ${inputDestructor}
135 ${extraDeclarations}
136 ${memberGetters}
137 ${memberDeclarations}
138 };""")
139
140     ImplementationSkeleton = (
141     """${licenseBlock}
142
143 #include "config.h"
144 #include "${filename}.h"
145
146 #if ${guardCondition}
147 ${includes}
148
149 namespace ${inputsNamespace} {
150 ${inputClassImplementations}
151 } // namespace ${inputsNamespace}
152
153 namespace ${traitsNamespace} {
154 ${inputTraitImplementations}
155 ${enumTraitImplementations}
156 } // namespace ${traitsNamespace}
157
158 #endif // ${guardCondition}
159 """)
160
161     InputTraitsImplementation = (
162     """const String& InputTraits<${qualifiedInputName}>::type()
163 {
164     static NeverDestroyed<const String> type(ASCIILiteral(${inputNameStringLiteral}));
165     return type;
166 }
167
168 void InputTraits<${qualifiedInputName}>::encode(EncodedValue& encodedValue, const ${qualifiedInputName}& input)
169 {
170 ${encodeSteps}
171 }
172
173 bool InputTraits<${qualifiedInputName}>::decode(EncodedValue& encodedValue, std::unique_ptr<${qualifiedInputName}>& input)
174 {
175 ${decodeSteps}
176     input = std::make_unique<${qualifiedInputName}>(${constructorArguments});
177     return true;
178 }""")
179
180     EnumClassTraitImplementation = (
181     """EncodedValue EncodingTraits<${encodingTypeArgument}>::encodeValue(const ${enumType}& enumValue)
182 {
183     switch (enumValue) {
184 ${encodeCases}
185     default: ASSERT_NOT_REACHED(); return EncodedValue::createString("Error!");
186     }
187 }
188
189 bool EncodingTraits<${encodingTypeArgument}>::decodeValue(EncodedValue& encodedValue, ${enumType}& enumValue)
190 {
191     String enumString = encodedValue.convertTo<String>();
192 ${decodeCases}
193     return false;
194 }""")
195
196     EnumClassEncodeCase = (
197     """    case ${qualifiedEnumValue}: return EncodedValue::createString("${enumStringValue}");""")
198
199     EnumClassDecodeCase = (
200     """    if (enumString == "${enumStringValue}") {
201         enumValue = ${qualifiedEnumValue};
202         return true;
203     }""")
204
205     EnumTraitImplementation = (
206     """EncodedValue EncodingTraits<${encodingTypeArgument}>::encodeValue(const ${enumType}& enumValue)
207 {
208     EncodedValue encodedValue = EncodedValue::createArray();
209 ${encodeCases}
210     return encodedValue;
211 }
212
213 bool EncodingTraits<${encodingTypeArgument}>::decodeValue(EncodedValue& encodedValue, ${enumType}& enumValue)
214 {
215     Vector<String> enumStrings;
216     if (!EncodingTraits<Vector<String>>::decodeValue(encodedValue, enumStrings))
217         return false;
218
219     for (const String& enumString : enumStrings) {
220 ${decodeCases}
221     }
222
223     return true;
224 }""")
225
226     EnumEncodeCase = (
227     """    if (enumValue & ${qualifiedEnumValue}) {
228         encodedValue.append<String>(ASCIILiteral("${enumStringValue}"));
229         if (enumValue == ${qualifiedEnumValue})
230             return encodedValue;
231     }""")
232
233     EnumDecodeCase = (
234     """        ${branchKeyword} (enumString == "${enumStringValue}")
235             enumValue = static_cast<${qualifiedEnumName}>(enumValue | ${qualifiedEnumValue});""")
236
237     InputClassImplementation = (
238     """${inputName}::${inputName}(${constructorFormalsList})
239 ${initializerList}
240 {
241 }
242
243 ${inputName}::~${inputName}()
244 {
245 }""")