OLD | NEW |
1 | 1 |
2 | 2 |
3 import sys | 3 import sys |
4 | 4 |
5 import datatypes | 5 import datatypes |
6 from autogen.pdfspec_autogen import * | 6 from autogen.pdfspec_autogen import * |
7 | 7 |
| 8 # TODO(edisonn): date and some other types are in fact strings, with a custom fo
rmat!!! |
| 9 # TODO(edisonn): refer to page 99 (PDF data types) |
8 knowTypes = { | 10 knowTypes = { |
9 '(any)': ['SkPdfObject*', 'SkPdfObjectFromDictionary', datatypes.CppNull(), 'tru
e', 'use a mapper'], | 11 '(any)': ['SkPdfObject*', 'ret', datatypes.CppNull(), 'true', 'use a mapper'], |
10 '(undefined)': ['SkPdfObject*', 'SkPdfObjectFromDictionary', datatypes.CppNull()
, 'true', 'use a mapper'], | 12 # TODO(edisonn): return constant for undefined |
11 '(various)': ['SkPdfObject*', 'SkPdfObjectFromDictionary', datatypes.CppNull(),
'true', 'use a mapper'], | 13 '(undefined)': ['SkPdfObject*', 'ret', datatypes.CppNull(), 'true', 'use a mappe
r'], |
12 'array': ['SkPdfArray*', 'ArrayFromDictionary', datatypes.CppNull(), 'ret->podof
o()->GetDataType() == PoDoFo::ePdfDataType_Array'], | 14 '(various)': ['SkPdfObject*', 'ret', datatypes.CppNull(), 'true', 'use a mapper'
], |
13 'boolean': ['bool', 'BoolFromDictionary', datatypes.PdfBoolean('false'), 'ret->p
odofo()->GetDataType() == PoDoFo::ePdfDataType_Bool'], | 15 'array': ['SkPdfArray*', '(SkPdfArray*)ret', datatypes.CppNull(), 'ret->isArray(
)'], |
14 'date': ['SkPdfDate', 'DateFromDictionary', datatypes.PdfDateNever(), 'ret->podo
fo()->GetDataType() == PoDoFo::ePdfDataType_Array'], | 16 'boolean': ['bool', 'ret->boolValue()', datatypes.PdfBoolean('false'), 'ret->isB
oolean()'], |
15 'dictionary': ['SkPdfDictionary*', 'SkPdfDictionaryFromDictionary', datatypes.Cp
pNull(), 'ret->podofo()->GetDataType() == PoDoFo::ePdfDataType_Dictionary', 'use
a mapper'], | 17 #date is a string, with special formating, add here the |
16 'function': ['SkPdfFunction', 'FunctionFromDictionary', datatypes.PdfFunctionNon
e(), 'ret->podofo()->GetDataType() == PoDoFo::ePdfDataType_Reference'], | 18 'date': ['SkPdfDate', 'ret->dateValue()', datatypes.PdfDateNever(), 'ret->isDate
()'], |
17 'integer': ['long', 'LongFromDictionary', datatypes.PdfInteger(0), 'ret->podofo(
)->GetDataType() == PoDoFo::ePdfDataType_Number'], | 19 'dictionary': ['SkPdfDictionary*', '(SkPdfDictionary*)ret', datatypes.CppNull(),
'ret->isDictionary()', 'use a mapper'], |
18 'file_specification': ['SkPdfFileSpec', 'FileSpecFromDictionary', datatypes.File
SpecNone(), 'ret->podofo()->GetDataType() == PoDoFo::ePdfDataType_Reference'], | 20 'function': ['SkPdfFunction', 'ret->functionValue()', datatypes.PdfFunctionNone(
), 'ret->isFunction()'], |
19 'name': ['std::string', 'NameFromDictionary', datatypes.PdfString('""'), 'ret->p
odofo()->GetDataType() == PoDoFo::ePdfDataType_Name'], | 21 'integer': ['int64_t', 'ret->intValue()', datatypes.PdfInteger(0), 'ret->isInteg
er()'], |
20 'tree': ['SkPdfTree*', 'TreeFromDictionary', datatypes.CppNull(), 'ret->podofo()
->GetDataType() == PoDoFo::ePdfDataType_Reference'], | 22 'file_specification': ['SkPdfFileSpec', 'ret->fileSpecValue()', datatypes.FileSp
ecNone(), 'false'], |
21 'number': ['double', 'DoubleFromDictionary', datatypes.PdfNumber(0), 'ret->podof
o()->GetDataType() == PoDoFo::ePdfDataType_Real || ret->podofo()->GetDataType()
== PoDoFo::ePdfDataType_Number'], | 23 'name': ['std::string', 'ret->nameValue2()', datatypes.PdfString('""'), 'ret->is
Name()'], |
22 'rectangle': ['SkRect*', 'SkRectFromDictionary', datatypes.CppNull(), 'ret->podo
fo()->GetDataType() == PoDoFo::ePdfDataType_Array && ret->podofo()->GetArray().G
etLength() == 4'], | 24 #should assert, references should never be allowed here, should be resolved way
earlier |
23 'stream': ['SkPdfStream*', 'StreamFromDictionary', datatypes.CppNull(), 'ret->p
odofo()->HasStream()'], | 25 'tree': ['SkPdfTree', 'ret->treeValue()', datatypes.EmptyTree(), 'false'], |
24 'string': ['std::string', 'StringFromDictionary', datatypes.PdfString('""'), 're
t->podofo()->GetDataType() == PoDoFo::ePdfDataType_String || ret->podofo()->GetD
ataType() == PoDoFo::ePdfDataType_HexString'], | 26 'number': ['double', 'ret->numberValue()', datatypes.PdfNumber(0), 'ret->isNumbe
r()'], |
25 'text': ['std::string', 'StringFromDictionary', datatypes.PdfString('""'), 'ret-
>podofo()->GetDataType() == PoDoFo::ePdfDataType_String || ret->podofo()->GetDat
aType() == PoDoFo::ePdfDataType_HexString'], | 27 'rectangle': ['SkRect', 'ret->rectangleValue()', datatypes.EmptyRect(), 'ret->is
Rectangle()'], |
26 'text string': ['std::string', 'StringFromDictionary', datatypes.PdfString('""')
, 'ret->podofo()->GetDataType() == PoDoFo::ePdfDataType_String || ret->podofo()-
>GetDataType() == PoDoFo::ePdfDataType_HexString'], | 28 'stream': ['SkPdfStream*', 'ret->getStream()', datatypes.CppNull(), 'ret->hasSt
ream()'], |
27 'matrix': ['SkMatrix*', 'SkMatrixFromDictionary', datatypes.CppNull(), 'ret->pod
ofo()->GetDataType() == PoDoFo::ePdfDataType_Array && ret->podofo()->GetArray().
GetLength() == 4'], | 29 'string': ['std::string', 'ret->stringValue2()', datatypes.PdfString('""'), 'ret
->isAnyString()'], |
| 30 'text': ['std::string', 'ret->stringValue2()', datatypes.PdfString('""'), 'ret->
isAnyString()'], |
| 31 'text string': ['std::string', 'ret->stringValue2()', datatypes.PdfString('""'),
'ret->isAnyString()'], |
| 32 'matrix': ['SkMatrix', 'ret->matrixValue()', datatypes.IdentityMatrix(), 'ret->i
sMatrix()'], |
28 } | 33 } |
29 | 34 |
30 | 35 |
31 class PdfField: | 36 class PdfField: |
32 def __init__(self, parent, name, abr): | 37 def __init__(self, parent, name, abr): |
33 self.fParent = parent | 38 self.fParent = parent |
34 self.fName = name | 39 self.fName = name |
35 self.fAbr = abr | 40 self.fAbr = abr |
36 | 41 |
37 self.fDefault = '' | 42 self.fDefault = '' |
(...skipping 56 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
94 self.fProp = PdfField(self, name, abr) | 99 self.fProp = PdfField(self, name, abr) |
95 return self.fProp | 100 return self.fProp |
96 | 101 |
97 def done(self): | 102 def done(self): |
98 return self.fParent | 103 return self.fParent |
99 | 104 |
100 class PdfClass: | 105 class PdfClass: |
101 def __init__(self, name, base, comment): | 106 def __init__(self, name, base, comment): |
102 self.fFields = [] | 107 self.fFields = [] |
103 self.fIncludes = [] | 108 self.fIncludes = [] |
104 self.fCCPublicPodofo = [] | 109 self.fCCPublicNative = [] |
105 self.fCCPublicPodofoCpp = [] | 110 self.fCCPublicNativeCpp = [] |
106 self.fName = name | 111 self.fName = name |
107 self.fBase = base | 112 self.fBase = base |
108 self.fComment = comment | 113 self.fComment = comment |
109 | 114 |
110 self.fEnumSubclasses = [] | 115 self.fEnumSubclasses = [] |
111 | 116 |
112 self.fEnum = '!UNDEFINED' | 117 self.fEnum = '!UNDEFINED' |
113 self.fEnumEnd = '!UNDEFINED' | 118 self.fEnumEnd = '!UNDEFINED' |
114 self.fCheck = '' | 119 self.fCheck = '' |
115 | 120 |
(...skipping 17 matching lines...) Expand all Loading... |
133 # ; separate props | 138 # ; separate props |
134 #inheritable | 139 #inheritable |
135 #version | 140 #version |
136 #required, if | 141 #required, if |
137 #optional, if | 142 #optional, if |
138 | 143 |
139 def include(self, path): | 144 def include(self, path): |
140 self.fIncludes.append(path) | 145 self.fIncludes.append(path) |
141 return self | 146 return self |
142 | 147 |
143 def carbonCopyPublicPodofo(self, cc): | 148 def carbonCopyPublicNative(self, cc): |
144 self.fCCPublicPodofo.append(cc) | 149 self.fCCPublicNative.append(cc) |
145 return self | 150 return self |
146 | 151 |
147 def carbonCopyPublicPodofoCpp(self, cc): | 152 def carbonCopyPublicNativeCpp(self, cc): |
148 self.fCCPublicPodofoCpp.append(cc) | 153 self.fCCPublicNativeCpp.append(cc) |
149 return self | 154 return self |
150 | 155 |
151 def done(self): | 156 def done(self): |
152 return | 157 return |
153 | 158 |
154 class PdfClassManager: | 159 class PdfClassManager: |
155 def __init__(self): | 160 def __init__(self): |
156 self.fClasses = {} | 161 self.fClasses = {} |
157 self.fClassesNamesInOrder = [] | 162 self.fClassesNamesInOrder = [] |
158 | 163 |
159 def addClass(self, name, base='Object', comment=''): | 164 def addClass(self, name, base='', comment=''): |
160 if name == 'Object': | 165 if name == 'Dictionary': |
161 cls = PdfClass(name, '', comment) | 166 cls = PdfClass(name, '', comment) |
162 else: | 167 else: |
163 cls = PdfClass(name, base, comment) | 168 cls = PdfClass(name, base, comment) |
164 self.fClasses[name] = cls | 169 self.fClasses[name] = cls |
165 self.fClassesNamesInOrder.append(name) | 170 self.fClassesNamesInOrder.append(name) |
166 return cls | 171 return cls |
167 | 172 |
168 def writeEnum(self, fileEnums, enum, enumToCls): | 173 def writeEnum(self, fileEnums, enum, enumToCls): |
169 fileEnums.write(' ' + enum + ',\n') | 174 fileEnums.write(' ' + enum + ',\n') |
170 cls = enumToCls[enum] | 175 cls = enumToCls[enum] |
171 cls.fEnumSubclasses.sort() | 176 cls.fEnumSubclasses.sort() |
172 | 177 |
173 cnt = 0 | 178 cnt = 0 |
174 for sub in cls.fEnumSubclasses: | 179 for sub in cls.fEnumSubclasses: |
175 self.writeEnum(fileEnums, cls.fEnumSubclasses[cnt], enumToCls) | 180 self.writeEnum(fileEnums, cls.fEnumSubclasses[cnt], enumToCls) |
176 cnt = cnt + 1 | 181 cnt = cnt + 1 |
177 | 182 |
178 if cnt != 0: | 183 if cnt != 0: |
179 fileEnums.write(' ' + cls.fEnumEnd + ',\n') | 184 fileEnums.write(' ' + cls.fEnumEnd + ',\n') |
180 | 185 |
181 | 186 |
182 def writeAsNull(self, podofoFileClass, cls, enumToCls): | 187 def writeAsNull(self, nativeFileClass, cls, enumToCls): |
183 podofoFileClass.write(' virtual SkPdf' + cls.fName +'* as' + cls.fName + '(
) {return NULL;}\n') | 188 nativeFileClass.write(' SkPdf' + cls.fName +'* as' + cls.fName + '() {retu
rn (SkPdf' + cls.fName + '*)this;}\n') |
184 podofoFileClass.write(' virtual const SkPdf' + cls.fName +'* as' + cls.fNa
me + '() const {return NULL;}\n') | 189 nativeFileClass.write(' const SkPdf' + cls.fName +'* as' + cls.fName + '()
const {return (const SkPdf' + cls.fName + '*)this;}\n') |
185 podofoFileClass.write('\n') | 190 nativeFileClass.write('\n') |
186 | 191 |
187 cnt = 0 | 192 cnt = 0 |
188 for sub in cls.fEnumSubclasses: | 193 for sub in cls.fEnumSubclasses: |
189 self.writeAsNull(podofoFileClass, enumToCls[cls.fEnumSubclasses[cnt]], enu
mToCls) | 194 self.writeAsNull(nativeFileClass, enumToCls[cls.fEnumSubclasses[cnt]], enu
mToCls) |
190 cnt = cnt + 1 | 195 cnt = cnt + 1 |
191 | 196 |
192 | 197 |
193 def writeAsFoo(self, podofoFileClass, cls, enumToCls): | 198 def writeAsFoo(self, nativeFileClass, cls, enumToCls): |
194 # TODO(edisonn): add a container, with sections, public, private, default, .
.. | 199 # TODO(edisonn): add a container, with sections, public, private, default, .
.. |
195 # the end code will be grouped | 200 # the end code will be grouped |
196 | 201 |
197 # me | 202 # me |
198 podofoFileClass.write('public:\n') | 203 nativeFileClass.write('public:\n') |
199 | 204 |
200 podofoFileClass.write('public:\n') | 205 nativeFileClass.write('public:\n') |
201 podofoFileClass.write(' SkPdf' + cls.fName +'* as' + cls.fName + '() {retu
rn this;}\n') | 206 nativeFileClass.write(' SkPdf' + cls.fName +'* as' + cls.fName + '() {retu
rn this;}\n') |
202 podofoFileClass.write(' virtual const SkPdf' + cls.fName +'* as' + cls.fNam
e + '() const {return this;}\n') | 207 nativeFileClass.write(' const SkPdf' + cls.fName +'* as' + cls.fName + '()
const {return this;}\n') |
203 podofoFileClass.write('\n') | 208 nativeFileClass.write('\n') |
204 | 209 |
205 if cls.fName == 'Object': | 210 if cls.fName == 'Dictionary': |
206 cnt = 0 | 211 cnt = 0 |
207 for sub in cls.fEnumSubclasses: | 212 for sub in cls.fEnumSubclasses: |
208 self.writeAsNull(podofoFileClass, enumToCls[cls.fEnumSubclasses[cnt]], e
numToCls) | 213 self.writeAsNull(nativeFileClass, enumToCls[cls.fEnumSubclasses[cnt]], e
numToCls) |
209 cnt = cnt + 1 | 214 cnt = cnt + 1 |
210 | 215 |
211 if cls.fName != 'Object': | 216 if cls.fName != 'Dictionary': |
212 podofoFileClass.write('private:\n') | 217 nativeFileClass.write('private:\n') |
213 base = self.fClasses[cls.fBase] | 218 base = self.fClasses[cls.fBase] |
214 cnt = 0 | 219 cnt = 0 |
215 for sub in base.fEnumSubclasses: | 220 for sub in base.fEnumSubclasses: |
216 if enumToCls[base.fEnumSubclasses[cnt]].fName != cls.fName: | 221 if enumToCls[base.fEnumSubclasses[cnt]].fName != cls.fName: |
217 self.writeAsNull(podofoFileClass, enumToCls[base.fEnumSubclasses[cnt]]
, enumToCls) | 222 self.writeAsNull(nativeFileClass, enumToCls[base.fEnumSubclasses[cnt]]
, enumToCls) |
218 cnt = cnt + 1 | 223 cnt = cnt + 1 |
219 | 224 |
220 | 225 |
221 def determineAllMustBe(self, cls, field, enumToCls): | 226 def determineAllMustBe(self, cls, field, enumToCls): |
222 mustBe = [] | 227 mustBe = [] |
223 for sub in cls.fEnumSubclasses: | 228 for sub in cls.fEnumSubclasses: |
224 mustBe = mustBe + self.determineAllMustBe(enumToCls[sub], field, enumToCls
) | 229 mustBe = mustBe + self.determineAllMustBe(enumToCls[sub], field, enumToCls
) |
225 | 230 |
226 for subField in cls.fFields: | 231 for subField in cls.fFields: |
227 if subField.fProp.fName == field.fProp.fName: | 232 if subField.fProp.fName == field.fProp.fName: |
228 mustBe = mustBe + subField.fProp.fMustBe | 233 mustBe = mustBe + subField.fProp.fMustBe |
229 | 234 |
230 # while cls.fBase != '': | 235 # while cls.fBase != '': |
231 # cls = self.fClasses[cls.fBase] | 236 # cls = self.fClasses[cls.fBase] |
232 # # TODO(edisonn): bad perf | 237 # # TODO(edisonn): bad perf |
233 # for subField in cls.fFields: | 238 # for subField in cls.fFields: |
234 # if subField.fProp.fName == field.fProp.fName: | 239 # if subField.fProp.fName == field.fProp.fName: |
235 # mustBe = mustBe + subField.fProp.fMustBe | 240 # mustBe = mustBe + subField.fProp.fMustBe |
236 | 241 |
237 return mustBe | 242 return mustBe |
238 | 243 |
239 def write(self): | 244 def write(self): |
240 global fileHeadersPodofo | 245 global fileHeadersNative |
241 global fileHeadersPodofoCpp | 246 global fileHeadersNativeCpp |
242 global knowTypes | 247 global knowTypes |
243 | 248 |
244 # generate enum | 249 # generate enum |
245 enumsRoot = [] | 250 enumsRoot = [] |
246 | 251 |
247 enumToCls = {} | 252 enumToCls = {} |
248 | 253 |
249 for name in self.fClasses: | 254 for name in self.fClasses: |
250 cls = self.fClasses[name] | 255 cls = self.fClasses[name] |
251 cls.fEnum = 'k' + name + '_SkPdfObjectType' | 256 cls.fEnum = 'k' + name + '_SkPdfObjectType' |
252 cls.fEnumEnd = 'k' + name + '__End_SkPdfObjectType' | 257 cls.fEnumEnd = 'k' + name + '__End_SkPdfObjectType' |
253 | 258 |
254 fileHeadersPodofo.write('#include "SkPdf' + cls.fName + '_autogen.h"\n') | 259 fileHeadersNative.write('#include "SkPdf' + cls.fName + '_autogen.h"\n') |
255 fileHeadersPodofoCpp.write('#include "SkPdf' + cls.fName + '_autogen.cpp"\
n') | 260 fileHeadersNativeCpp.write('#include "SkPdf' + cls.fName + '_autogen.cpp"\
n') |
256 | 261 |
257 if cls.fBase != '': | 262 if cls.fBase != '': |
258 self.fClasses[cls.fBase].fEnumSubclasses.append(cls.fEnum) | 263 self.fClasses[cls.fBase].fEnumSubclasses.append(cls.fEnum) |
259 | 264 |
260 if cls.fBase == '': | 265 if cls.fBase == '': |
261 enumsRoot.append(cls.fEnum) | 266 enumsRoot.append(cls.fEnum) |
262 | 267 |
263 enumToCls[cls.fEnum] = cls | 268 enumToCls[cls.fEnum] = cls |
264 | 269 |
265 enumsRoot.sort() | 270 enumsRoot.sort() |
266 | 271 |
267 | 272 |
268 # TODO(edisonn): move each .h in it's own file | 273 # TODO(edisonn): move each .h in it's own file |
269 # write imports | 274 # write imports |
270 | 275 |
271 # write enums | 276 # write enums |
272 fileEnums = open(sys.argv[1] + 'autogen/SkPdfEnums_autogen.h', 'w') | 277 fileEnums = open(sys.argv[1] + 'autogen/SkPdfEnums_autogen.h', 'w') |
273 fileEnums.write('#ifndef __DEFINED__SkPdfEnums\n') | 278 fileEnums.write('#ifndef __DEFINED__SkPdfEnums\n') |
274 fileEnums.write('#define __DEFINED__SkPdfEnums\n') | 279 fileEnums.write('#define __DEFINED__SkPdfEnums\n') |
275 fileEnums.write('\n') | 280 fileEnums.write('\n') |
276 | 281 |
277 fileEnums.write('enum SkPdfObjectType {\n') | 282 fileEnums.write('enum SkPdfObjectType {\n') |
| 283 fileEnums.write(' kNone_SkPdfObjectType = 0,\n') |
278 for enum in enumsRoot: | 284 for enum in enumsRoot: |
279 self.writeEnum(fileEnums, enum, enumToCls) | 285 self.writeEnum(fileEnums, enum, enumToCls) |
280 fileEnums.write('};\n') | 286 fileEnums.write('};\n') |
281 fileEnums.write('\n') | 287 fileEnums.write('\n') |
282 | 288 |
283 # write forward class declaration | 289 # write forward class declaration |
284 for name in self.fClassesNamesInOrder: | 290 for name in self.fClassesNamesInOrder: |
285 fileEnums.write('class SkPdf' + name + ';\n') | 291 fileEnums.write('class SkPdf' + name + ';\n') |
286 fileEnums.write('\n') | 292 fileEnums.write('\n') |
287 | 293 |
288 fileEnums.write('#endif // __DEFINED__SkPdfEnums\n') | 294 fileEnums.write('#endif // __DEFINED__SkPdfEnums\n') |
289 fileEnums.close() | 295 fileEnums.close() |
290 | 296 |
291 for name in self.fClassesNamesInOrder: | 297 for name in self.fClassesNamesInOrder: |
292 cls = self.fClasses[name] | 298 cls = self.fClasses[name] |
293 enum = cls.fEnum | 299 enum = cls.fEnum |
294 | 300 |
295 podofoFileClass = open(sys.argv[1] + 'podofo/autogen/SkPdf' + cls.fName +
'_autogen.h', 'w') | 301 nativeFileClass = open(sys.argv[1] + 'native/autogen/SkPdf' + cls.fName +
'_autogen.h', 'w') |
296 podofoFileClassCpp = open(sys.argv[1] + 'podofo/autogen/SkPdf' + cls.fName
+ '_autogen.cpp', 'w') | 302 nativeFileClassCpp = open(sys.argv[1] + 'native/autogen/SkPdf' + cls.fName
+ '_autogen.cpp', 'w') |
297 | 303 |
298 podofoFileClass.write('#ifndef __DEFINED__SkPdf' + cls.fName + '\n') | 304 nativeFileClass.write('#ifndef __DEFINED__SkPdf' + cls.fName + '\n') |
299 podofoFileClass.write('#define __DEFINED__SkPdf' + cls.fName + '\n') | 305 nativeFileClass.write('#define __DEFINED__SkPdf' + cls.fName + '\n') |
300 podofoFileClass.write('\n') | 306 nativeFileClass.write('\n') |
301 | 307 |
302 podofoFileClassCpp.write('#include "SkPdf' + cls.fName + '_autogen.h"\n\n'
) | 308 nativeFileClassCpp.write('#include "SkPdf' + cls.fName + '_autogen.h"\n\n'
) |
303 podofoFileClassCpp.write('#include "podofo.h"\n') | 309 nativeFileClassCpp.write('\n') |
304 podofoFileClassCpp.write('#include "SkPodofoUtils.h"\n') | |
305 podofoFileClassCpp.write('#include "SkPdfMapper_autogen.h"\n') | |
306 podofoFileClassCpp.write('\n') | |
307 | 310 |
308 | 311 |
309 if cls.fBase == '': | 312 if cls.fBase == '': |
310 podofoFileClass.write('#include "stddef.h"\n') | 313 nativeFileClass.write('#include "stddef.h"\n') |
311 podofoFileClass.write('#include <string>\n') | 314 nativeFileClass.write('#include <string>\n') |
312 podofoFileClass.write('#include "SkPdfEnums_autogen.h"\n') | 315 nativeFileClass.write('#include "SkPdfEnums_autogen.h"\n') |
313 podofoFileClass.write('#include "SkPdfNYI.h"\n') | 316 nativeFileClass.write('#include "SkPdfNYI.h"\n') |
314 podofoFileClass.write('#include "SkPodofoUtils.h"\n') | 317 nativeFileClass.write('#include "SkPdfObject.h"\n') |
| 318 nativeFileClass.write('class SkNativeParsedPDF;\n') |
315 | 319 |
316 if cls.fBase != '': | 320 if cls.fBase != '': |
317 podofoFileClass.write('#include "SkPdf' + cls.fBase + '_autogen.h"\n') | 321 nativeFileClass.write('#include "SkPdf' + cls.fBase + '_autogen.h"\n') |
318 | 322 |
319 if cls.fBase == '': | 323 nativeFileClassCpp.write('#include "SkNativeParsedPDF.h"\n') |
320 podofoFileClass.write('#include "SkPodofoParsedPDF.h"\n') | |
321 | 324 |
322 podofoFileClass.write('\n') | 325 |
| 326 nativeFileClass.write('\n') |
| 327 |
| 328 if cls.fComment != '': |
| 329 nativeFileClass.write('// ' + cls.fComment + '\n') |
323 | 330 |
324 if cls.fBase == '': | 331 if cls.fBase == '': |
325 podofoFileClass.write('namespace PoDoFo {\n') | 332 nativeFileClass.write('class SkPdf' + cls.fName + ' : public SkPdfObject
{\n') |
326 podofoFileClass.write('class PdfMemDocument;\n') | 333 else: |
327 podofoFileClass.write('class PdfObject;\n') | 334 nativeFileClass.write('class SkPdf' + cls.fName + ' : public SkPdf' + cl
s.fBase + ' {\n') |
328 podofoFileClass.write('}\n') | |
329 | 335 |
330 if cls.fComment != '': | 336 self.writeAsFoo(nativeFileClass, cls, enumToCls) |
331 podofoFileClass.write('// ' + cls.fComment + '\n') | |
332 | 337 |
333 if cls.fBase == '': | 338 nativeFileClass.write('public:\n') |
334 podofoFileClass.write('class SkPdf' + cls.fName + ' {\n') | 339 |
335 else: | 340 for cc in cls.fCCPublicNative: |
336 podofoFileClass.write('class SkPdf' + cls.fName + ' : public SkPdf' + cl
s.fBase + ' {\n') | 341 nativeFileClass.write(' ' + cc + '\n') |
337 | 342 |
338 podofoFileClass.write('public:\n') | 343 for cc in cls.fCCPublicNativeCpp: |
339 podofoFileClass.write(' virtual SkPdfObjectType getType() const { return
' + cls.fEnum + ';}\n') | 344 nativeFileClassCpp.write(cc + '\n\n') |
340 if len(cls.fEnumSubclasses) == 0: | |
341 podofoFileClass.write(' virtual SkPdfObjectType getTypeEnd() const { re
turn (SkPdfObjectType)(' + cls.fEnum + ' + 1);}\n') | |
342 else: | |
343 podofoFileClass.write(' virtual SkPdfObjectType getTypeEnd() const { re
turn ' + cls.fEnumEnd + ';}\n') | |
344 | |
345 self.writeAsFoo(podofoFileClass, cls, enumToCls) | |
346 | |
347 podofoFileClass.write('public:\n') | |
348 | |
349 for cc in cls.fCCPublicPodofo: | |
350 podofoFileClass.write(' ' + cc + '\n') | |
351 | |
352 for cc in cls.fCCPublicPodofoCpp: | |
353 podofoFileClassCpp.write(cc + '\n\n') | |
354 | 345 |
355 | 346 |
356 if cls.fBase == '': | 347 if cls.fBase == '': |
357 podofoFileClass.write('protected:\n') | 348 nativeFileClass.write('public:\n') |
358 podofoFileClass.write(' const PoDoFo::PdfMemDocument* fPodofoDoc;\n') | |
359 podofoFileClass.write(' const SkPodofoParsedPDF* fParsedDoc;\n') | |
360 podofoFileClass.write(' const PoDoFo::PdfObject* fPodofoObj;\n') | |
361 podofoFileClass.write('\n') | |
362 | 349 |
363 podofoFileClass.write('public:\n') | |
364 | |
365 podofoFileClass.write(' SkPdf' + cls.fName + '(const SkPodofoParsedPDF*
doc = NULL, const PoDoFo::PdfObject* podofoObj = NULL) : fPodofoDoc(doc->podofo
()), fParsedDoc(doc), fPodofoObj(podofoObj) {}\n') | |
366 podofoFileClass.write('\n') | |
367 podofoFileClass.write(' const SkPodofoParsedPDF* doc() const { return f
ParsedDoc;}\n') | |
368 podofoFileClass.write(' const void* data() const {return fPodofoObj;}\n
') | |
369 podofoFileClass.write(' const PoDoFo::PdfObject* podofo() const {return
fPodofoObj;}\n') | |
370 else: | |
371 podofoFileClass.write('public:\n') | |
372 podofoFileClass.write(' SkPdf' + cls.fName + '(const SkPodofoParsedPDF*
doc = NULL, const PoDoFo::PdfObject* podofoObj = NULL) : SkPdf' + cls.fBase + '
(doc, podofoObj) {}\n') | |
373 podofoFileClass.write('\n') | |
374 | |
375 | |
376 # TODO(edisonn): add is valid ? | 350 # TODO(edisonn): add is valid ? |
377 #check required fieds, also, there should be an internal_valid() manually
wrote for complex | 351 #check required fieds, also, there should be an internal_valid() manually
wrote for complex |
378 # situations | 352 # situations |
379 # right now valid return true | 353 # right now valid return true |
380 #podofoFileClass.write(' virtual bool valid() const {return true;}\n') | 354 # TODO(edisonn): cache the value of valid, have a set of bits that would r
emember what types are valid for this type |
381 #podofoFileClass.write('\n') | 355 nativeFileClass.write(' bool valid() const {return true;}\n') |
| 356 #nativeFileClass.write('\n') |
382 | 357 |
383 for field in cls.fFields: | 358 for field in cls.fFields: |
384 prop = field.fProp | 359 prop = field.fProp |
385 if prop.fCppName != '': | 360 if prop.fCppName != '': |
386 | 361 |
387 lines = prop.fComment.split('\n') | 362 lines = prop.fComment.split('\n') |
388 if prop.fComment != '' and len(lines) > 0: | 363 if prop.fComment != '' and len(lines) > 0: |
389 podofoFileClass.write('/** ' + lines[0] + '\n') | 364 nativeFileClass.write('/** ' + lines[0] + '\n') |
390 for line in lines[1:]: | 365 for line in lines[1:]: |
391 podofoFileClass.write(' * ' + line + '\n') | 366 nativeFileClass.write(' * ' + line + '\n') |
392 podofoFileClass.write('**/\n') | 367 nativeFileClass.write('**/\n') |
393 | 368 |
394 if prop.fCppName[0] == '[': | 369 if prop.fCppName[0] == '[': |
395 podofoFileClass.write('/*\n') # comment code of the atributes that
can have any name | 370 nativeFileClass.write('/*\n') # comment code of the atributes that
can have any name |
396 podofoFileClassCpp.write('/*\n') # comment code of the atributes th
at can have any name | 371 nativeFileClassCpp.write('/*\n') # comment code of the atributes th
at can have any name |
397 | 372 |
398 | 373 |
399 if len(prop.fTypes.split()) == 1: | 374 if len(prop.fTypes.split()) == 1: |
400 t = prop.fTypes.strip() | 375 t = prop.fTypes.strip() |
401 | 376 |
402 podofoFileClass.write(' ' + knowTypes[t][0] + ' ' + prop.fCppName +
'() const;\n') | 377 nativeFileClass.write(' ' + knowTypes[t][0] + ' ' + prop.fCppName +
'(const SkNativeParsedPDF* doc);\n') |
403 podofoFileClassCpp.write('' + knowTypes[t][0] + ' SkPdf' + cls.fName
+ '::' + prop.fCppName + '() const {\n') | 378 nativeFileClassCpp.write('' + knowTypes[t][0] + ' SkPdf' + cls.fName
+ '::' + prop.fCppName + '(const SkNativeParsedPDF* doc) {\n') |
404 podofoFileClassCpp.write(' ' + knowTypes[t][0] + ' ret;\n') | 379 nativeFileClassCpp.write(' SkPdfObject* ret = get(\"' + prop.fName
+ '\", \"' + prop.fAbr + '\");\n') |
| 380 nativeFileClassCpp.write(' if (doc) {ret = doc->resolveReference(re
t);}\n') |
| 381 nativeFileClassCpp.write(' if ((ret != NULL && ' + knowTypes[t][3]
+ ') || (doc == NULL && ret != NULL && ret->isReference())) return ' + knowTypes
[t][1] + ';\n') |
405 | 382 |
406 #hack, find out if it is dict, they have an extra entry in the array | 383 if field.fRequired: |
407 if len(knowTypes[t]) == 5: | 384 nativeFileClassCpp.write(' // TODO(edisonn): warn about missing r
equired field, assert for known good pdfs\n') |
408 podofoFileClassCpp.write(' if (fParsedDoc->mapper()->' + knowType
s[t][1] + '(podofo()->GetDictionary(), \"' + prop.fName + '\", \"' + prop.fAbr +
'\", &ret)) return ret;\n') | 385 nativeFileClassCpp.write(' return ' + knowTypes[t][2].toCpp() + '
;\n'); |
| 386 elif prop.fDefault != '': |
| 387 nativeFileClassCpp.write(' return ' + prop.fDefault.toCpp() + ';\
n'); |
409 else: | 388 else: |
410 podofoFileClassCpp.write(' if (' + knowTypes[t][1] + '(fParsedDoc
, podofo()->GetDictionary(), \"' + prop.fName + '\", \"' + prop.fAbr + '\", &ret
)) return ret;\n') | 389 nativeFileClassCpp.write(' // TODO(edisonn): warn about missing d
efault value for optional fields\n') |
| 390 nativeFileClassCpp.write(' return ' + knowTypes[t][2].toCpp() + '
;\n'); |
411 | 391 |
412 if field.fRequired == False and prop.fDefault != '': | 392 nativeFileClassCpp.write('}\n') |
413 podofoFileClassCpp.write(' return ' + prop.fDefault.toCpp() + ';\
n'); | 393 nativeFileClassCpp.write('\n') |
414 else: | |
415 podofoFileClassCpp.write(' // TODO(edisonn): warn about missing r
equired field, assert for known good pdfs\n') | |
416 podofoFileClassCpp.write(' return ' + knowTypes[t][2].toCpp() + '
;\n'); | |
417 podofoFileClassCpp.write('}\n') | |
418 podofoFileClassCpp.write('\n') | |
419 else: | 394 else: |
420 for type in prop.fTypes.split(): | 395 for type in prop.fTypes.split(): |
421 t = type.strip() | 396 t = type.strip() |
422 | 397 |
423 podofoFileClass.write(' bool is' + prop.fCppName + 'A' + t.title(
) + '() const;\n') | 398 nativeFileClass.write(' bool is' + prop.fCppName + 'A' + t.title(
) + '(const SkNativeParsedPDF* doc);\n') |
424 | 399 |
425 podofoFileClassCpp.write('bool SkPdf' + cls.fName + '::is' + prop.
fCppName + 'A' + t.title() + '() const {\n') | 400 nativeFileClassCpp.write('bool SkPdf' + cls.fName + '::is' + prop.
fCppName + 'A' + t.title() + '(const SkNativeParsedPDF* doc) {\n') |
426 podofoFileClassCpp.write(' SkPdfObject* ret = NULL;\n') | 401 nativeFileClassCpp.write(' SkPdfObject* ret = get(\"' + prop.fNam
e + '\", \"' + prop.fAbr + '\");\n') |
427 podofoFileClassCpp.write(' if (!fParsedDoc->mapper()->SkPdfObject
FromDictionary(podofo()->GetDictionary(), \"' + prop.fName + '\", \"' + prop.fAb
r + '\", &ret)) return false;\n') | 402 nativeFileClassCpp.write(' if (doc) {ret = doc->resolveReference(
ret);}\n') |
428 podofoFileClassCpp.write(' return ' + knowTypes[t][3] + ';\n') | 403 nativeFileClassCpp.write(' return ret != NULL && ' + knowTypes[t]
[3] + ';\n') |
429 podofoFileClassCpp.write('}\n') | 404 nativeFileClassCpp.write('}\n') |
430 podofoFileClassCpp.write('\n') | 405 nativeFileClassCpp.write('\n') |
431 | 406 |
432 podofoFileClass.write(' ' + knowTypes[t][0] + ' get' + prop.fCppN
ame + 'As' + t.title() + '() const;\n') | 407 nativeFileClass.write(' ' + knowTypes[t][0] + ' get' + prop.fCppN
ame + 'As' + t.title() + '(const SkNativeParsedPDF* doc);\n') |
433 podofoFileClassCpp.write('' + knowTypes[t][0] + ' SkPdf' + cls.fNa
me + '::get' + prop.fCppName + 'As' + t.title() + '() const {\n') | 408 nativeFileClassCpp.write('' + knowTypes[t][0] + ' SkPdf' + cls.fNa
me + '::get' + prop.fCppName + 'As' + t.title() + '(const SkNativeParsedPDF* doc
) {\n') |
434 podofoFileClassCpp.write(' ' + knowTypes[t][0] + ' ret = ' + know
Types[t][2].toCpp() + ';\n') | |
435 | 409 |
436 # hack | 410 nativeFileClassCpp.write(' SkPdfObject* ret = get(\"' + prop.fNam
e + '\", \"' + prop.fAbr + '\");\n') |
437 if len(knowTypes[t]) == 5: | 411 nativeFileClassCpp.write(' if (doc) {ret = doc->resolveReference(
ret);}\n') |
438 podofoFileClassCpp.write(' if (fParsedDoc->mapper()->' + knowTy
pes[t][1] + '(podofo()->GetDictionary(), \"' + prop.fName + '\", \"' + prop.fAbr
+ '\", &ret)) return ret;\n') | 412 nativeFileClassCpp.write(' if ((ret != NULL && ' + knowTypes[t][3
] + ') || (doc == NULL && ret != NULL && ret->isReference())) return ' + knowTyp
es[t][1] + ';\n') |
| 413 |
| 414 |
| 415 if field.fRequired: |
| 416 nativeFileClassCpp.write(' // TODO(edisonn): warn about missing
required field, assert for known good pdfs\n') |
| 417 nativeFileClassCpp.write(' return ' + knowTypes[t][2].toCpp() +
';\n'); |
| 418 elif prop.fDefault != '': |
| 419 nativeFileClassCpp.write(' return ' + prop.fDefault.toCpp() + '
;\n'); |
439 else: | 420 else: |
440 podofoFileClassCpp.write(' if (' + knowTypes[t][1] + '(fParsedD
oc, podofo()->GetDictionary(), \"' + prop.fName + '\", \"' + prop.fAbr + '\", &r
et)) return ret;\n') | 421 nativeFileClassCpp.write(' // TODO(edisonn): warn about missing
default value for optional fields\n') |
441 | 422 nativeFileClassCpp.write(' return ' + knowTypes[t][2].toCpp() +
';\n'); |
442 podofoFileClassCpp.write(' // TODO(edisonn): warn about missing r
equired field, assert for known good pdfs\n') | 423 |
443 podofoFileClassCpp.write(' return ' + knowTypes[t][2].toCpp() + '
;\n') | 424 nativeFileClassCpp.write('}\n') |
444 podofoFileClassCpp.write('}\n') | 425 nativeFileClassCpp.write('\n') |
445 podofoFileClassCpp.write('\n') | |
446 | 426 |
447 podofoFileClass.write(' bool has_' + prop.fCppName + '() const;\n') | 427 nativeFileClass.write(' bool has_' + prop.fCppName + '() const;\n') |
448 podofoFileClassCpp.write('bool SkPdf' + cls.fName + '::has_' + prop.fC
ppName + '() const {\n') | 428 nativeFileClassCpp.write('bool SkPdf' + cls.fName + '::has_' + prop.fC
ppName + '() const {\n') |
449 podofoFileClassCpp.write(' return (ObjectFromDictionary(fParsedDoc, p
odofo()->GetDictionary(), \"' + prop.fName + '\", \"' + prop.fAbr + '\", NULL));
\n') | 429 # TODO(edisonn): has_foo() does not check type, add has_valid_foo(), a
nd check that type is expected (e.g. number, string, ...) |
450 podofoFileClassCpp.write('}\n') | 430 nativeFileClassCpp.write(' return get(\"' + prop.fName + '\", \"' + p
rop.fAbr + '\") != NULL;\n') |
451 podofoFileClassCpp.write('\n') | 431 nativeFileClassCpp.write('}\n') |
| 432 nativeFileClassCpp.write('\n') |
452 | 433 |
453 if prop.fCppName[0] == '[': | 434 if prop.fCppName[0] == '[': |
454 podofoFileClass.write('*/\n') # comment code of the atributes that
can have any name | 435 nativeFileClass.write('*/\n') # comment code of the atributes that
can have any name |
455 podofoFileClassCpp.write('*/\n') # comment code of the atributes th
at can have any name | 436 nativeFileClassCpp.write('*/\n') # comment code of the atributes th
at can have any name |
456 | 437 |
457 | 438 |
458 podofoFileClass.write('};\n') | 439 nativeFileClass.write('};\n') |
459 podofoFileClass.write('\n') | 440 nativeFileClass.write('\n') |
460 | 441 |
461 podofoFileClass.write('#endif // __DEFINED__PODOFO_SkPdf' + cls.fName + '
\n') | 442 nativeFileClass.write('#endif // __DEFINED__NATIVE_SkPdf' + cls.fName + '
\n') |
462 | 443 |
463 podofoFileClass.close() | 444 nativeFileClass.close() |
464 podofoFileClassCpp.close() | 445 nativeFileClassCpp.close() |
465 | 446 |
466 # generate constructor when knowing the type | 447 # generate constructor when knowing the type |
467 # later, p2, generate constructor when not knowing the type - very similar
with parsing? | 448 # later, p2, generate constructor when not knowing the type - very similar
with parsing? |
468 | 449 |
469 # generate parser | 450 # generate parser |
470 # TODO(edisonn): fast recognition based on must attributes. | 451 # TODO(edisonn): fast recognition based on must attributes. |
471 fileMapperPodofo = open(sys.argv[1] + 'podofo/autogen/SkPdfMapper_autogen.h'
, 'w') | 452 fileMapperNative = open(sys.argv[1] + 'native/autogen/SkPdfMapper_autogen.h'
, 'w') |
472 fileMapperPodofoCpp = open(sys.argv[1] + 'podofo/autogen/SkPdfMapper_autogen
.cpp', 'w') | 453 fileMapperNativeCpp = open(sys.argv[1] + 'native/autogen/SkPdfMapper_autogen
.cpp', 'w') |
473 | 454 |
474 fileMapperPodofo.write('#ifndef __DEFINED__SkPdfMapper\n') | 455 fileMapperNative.write('#ifndef __DEFINED__SkPdfMapper\n') |
475 fileMapperPodofo.write('#define __DEFINED__SkPdfMapper\n') | 456 fileMapperNative.write('#define __DEFINED__SkPdfMapper\n') |
476 fileMapperPodofo.write('\n') | 457 fileMapperNative.write('\n') |
477 | 458 |
478 fileMapperPodofo.write('#include "SkPdfHeaders_autogen.h"\n') | 459 fileMapperNative.write('#include "SkPdfHeaders_autogen.h"\n') |
| 460 fileMapperNative.write('#include "SkNativeParsedPDF.h"\n') |
| 461 fileMapperNative.write('#include "SkPdfObject.h"\n') |
479 | 462 |
480 | 463 |
481 fileMapperPodofo.write('namespace PoDoFo {\n') | 464 fileMapperNativeCpp.write('#include "SkPdfMapper_autogen.h"\n') |
482 fileMapperPodofo.write('class PdfDictionary;\n') | 465 fileMapperNativeCpp.write('#include "SkPdfUtils.h"\n') |
483 fileMapperPodofo.write('class PdfMemDocument;\n') | 466 fileMapperNativeCpp.write('#include "SkPdfObject.h"\n') |
484 fileMapperPodofo.write('class PdfObject;\n') | 467 fileMapperNativeCpp.write('\n') |
485 fileMapperPodofo.write('}\n') | 468 |
| 469 fileMapperNative.write('class SkPdfMapper {\n') |
486 | 470 |
487 fileMapperPodofoCpp.write('#include "SkPdfMapper_autogen.h"\n') | 471 fileMapperNative.write(' const SkNativeParsedPDF* fParsedDoc;\n') |
488 fileMapperPodofoCpp.write('#include "SkPdfUtils.h"\n') | |
489 fileMapperPodofoCpp.write('#include "podofo.h"\n') | |
490 fileMapperPodofoCpp.write('\n') | |
491 | 472 |
492 fileMapperPodofo.write('class SkPdfMapper {\n') | 473 fileMapperNative.write('public:\n') |
493 | |
494 fileMapperPodofo.write(' const SkPodofoParsedPDF* fParsedDoc;\n') | |
495 fileMapperPodofo.write(' const PoDoFo::PdfMemDocument* fPodofoDoc;\n') | |
496 | 474 |
497 fileMapperPodofo.write('public:\n') | 475 fileMapperNative.write(' SkPdfMapper(const SkNativeParsedPDF* doc) : fParse
dDoc(doc) {}\n') |
498 | 476 fileMapperNative.write('\n') |
499 fileMapperPodofo.write(' SkPdfMapper(const SkPodofoParsedPDF* doc) : fParse
dDoc(doc), fPodofoDoc(doc ? doc->podofo() : NULL) {}\n') | |
500 fileMapperPodofo.write('\n') | |
501 | 477 |
502 for name in self.fClassesNamesInOrder: | 478 for name in self.fClassesNamesInOrder: |
503 cls = self.fClasses[name] | 479 cls = self.fClasses[name] |
504 | 480 |
505 fileMapperPodofo.write(' bool map' + name + '(const SkPdfObject* in, SkPd
f' + name + '** out) const;\n') | 481 fileMapperNative.write(' SkPdfObjectType map' + name + '(const SkPdfObjec
t* in) const;\n') |
506 | 482 |
507 fileMapperPodofoCpp.write('bool SkPdfMapper::map' + name + '(const SkPdfOb
ject* in, SkPdf' + name + '** out) const {\n') | 483 fileMapperNativeCpp.write('SkPdfObjectType SkPdfMapper::map' + name + '(co
nst SkPdfObject* in) const {\n') |
508 fileMapperPodofoCpp.write(' return map' + name + '((const PoDoFo::PdfObje
ct*)in->data(), (SkPdf' + name + '**)out);\n') | 484 fileMapperNativeCpp.write(' if (!is' + name + '(in)) return kNone_SkPdfOb
jectType;\n') |
509 fileMapperPodofoCpp.write('}\n') | 485 fileMapperNativeCpp.write('\n') |
510 fileMapperPodofoCpp.write('\n') | 486 if len(cls.fEnumSubclasses) > 0: |
511 | 487 fileMapperNativeCpp.write(' SkPdfObjectType ret;\n') |
512 fileMapperPodofo.write(' bool map' + name + '(const PoDoFo::PdfObject* po
dofoObj, SkPdf' + name + '** out) const ;\n') | |
513 fileMapperPodofoCpp.write('bool SkPdfMapper::map' + name + '(const PoDoFo:
:PdfObject* podofoObj, SkPdf' + name + '** out) const {\n') | |
514 fileMapperPodofoCpp.write(' if (!is' + name + '(podofoObj)) return false;
\n') | |
515 fileMapperPodofoCpp.write('\n') | |
516 | 488 |
517 # stream must be last one | 489 # stream must be last one |
518 hasStream = False | 490 hasStream = False |
519 for sub in cls.fEnumSubclasses: | 491 for sub in cls.fEnumSubclasses: |
520 if cls.fName == 'Object' and enumToCls[sub].fName == 'Stream': | 492 fileMapperNativeCpp.write(' if (kNone_SkPdfObjectType != (ret = map' +
enumToCls[sub].fName + '(in))) return ret;\n') |
521 hasStream = True | |
522 else: | |
523 fileMapperPodofoCpp.write(' if (map' + enumToCls[sub].fName + '(podof
oObj, (SkPdf' + enumToCls[sub].fName + '**)out)) return true;\n') | |
524 | 493 |
525 if hasStream: | 494 fileMapperNativeCpp.write('\n') |
526 fileMapperPodofoCpp.write(' if (mapStream(podofoObj, (SkPdfStream**)out
)) return true;\n') | |
527 | 495 |
528 | 496 fileMapperNativeCpp.write(' return k' + name + '_SkPdfObjectType;\n')
|
529 fileMapperPodofoCpp.write('\n') | 497 fileMapperNativeCpp.write('}\n') |
530 | 498 fileMapperNativeCpp.write('\n') |
531 fileMapperPodofoCpp.write(' *out = new SkPdf' + name + '(fParsedDoc, podo
foObj);\n') | |
532 fileMapperPodofoCpp.write(' return true;\n') | |
533 fileMapperPodofoCpp.write('}\n') | |
534 fileMapperPodofoCpp.write('\n') | |
535 | 499 |
536 for name in self.fClassesNamesInOrder: | 500 for name in self.fClassesNamesInOrder: |
537 cls = self.fClasses[name] | 501 cls = self.fClasses[name] |
538 | 502 |
539 fileMapperPodofo.write(' bool is' + name + '(const PoDoFo::PdfObject* pod
ofoObj) const ;\n') | 503 fileMapperNative.write(' bool is' + name + '(const SkPdfObject* nativeObj
) const ;\n') |
540 fileMapperPodofoCpp.write('bool SkPdfMapper::is' + name + '(const PoDoFo::
PdfObject* podofoObj) const {\n') | 504 fileMapperNativeCpp.write('bool SkPdfMapper::is' + name + '(const SkPdfObj
ect* nativeObj) const {\n') |
541 | 505 |
542 if cls.fCheck != '': | 506 if cls.fCheck != '': |
543 fileMapperPodofoCpp.write(' return ' + cls.fCheck + ';\n') | 507 fileMapperNativeCpp.write(' return ' + cls.fCheck + ';\n') |
544 else: | 508 else: |
545 cntMust = 0 | 509 cntMust = 0 |
| 510 emitedRet = False |
546 for field in cls.fFields: | 511 for field in cls.fFields: |
547 prop = field.fProp | 512 prop = field.fProp |
548 if prop.fHasMust: | 513 if prop.fHasMust: |
| 514 if emitedRet == False: |
| 515 fileMapperNativeCpp.write(' const SkPdfObject* ret = NULL;\n') |
| 516 emitedRet = True |
549 cntMust = cntMust + 1 | 517 cntMust = cntMust + 1 |
550 fileMapperPodofoCpp.write(' ' + knowTypes[prop.fTypes.strip()][0] +
' ' + prop.fCppName + ';\n') | 518 fileMapperNativeCpp.write(' if (!nativeObj->isDictionary()) return
false;\n') |
551 fileMapperPodofoCpp.write(' if (!podofoObj->IsDictionary()) return
false;\n') | 519 fileMapperNativeCpp.write(' ret = nativeObj->get(\"' + prop.fName +
'\", \"' + prop.fAbr + '\");\n') |
552 fileMapperPodofoCpp.write(' if (!' + knowTypes[prop.fTypes.strip()]
[1] + '(fParsedDoc, podofoObj->GetDictionary(), \"' + prop.fName + '\", \"' + pr
op.fAbr + '\", &' + prop.fCppName + ')) return false;\n') | 520 fileMapperNativeCpp.write(' if (ret == NULL) return false;\n') |
553 | 521 |
554 eval = ''; | 522 eval = ''; |
555 # TODO(edisonn): this could get out of hand, and could have poor per
formance if continued on this path | 523 # TODO(edisonn): this could get out of hand, and could have poor per
formance if continued on this path |
556 # but if we would write our parser, then best thing would be to crea
te a map of (key, value) -> to bits | 524 # but if we would write our parser, then best thing would be to crea
te a map of (key, value) -> to bits |
557 # and at each (key, value) we do an and with the bits existent, then
we check what bits are left, which would tell the posible types of this diction
ary | 525 # and at each (key, value) we do an and with the bits existent, then
we check what bits are left, which would tell the posible types of this diction
ary |
558 # and for non unique posinilities (if any) based on context, or the
requester of dictionry we can determine fast the dictionary type | 526 # and for non unique posinilities (if any) based on context, or the
requester of dictionry we can determine fast the dictionary type |
559 mustBe = self.determineAllMustBe(cls, field, enumToCls) | 527 mustBe = self.determineAllMustBe(cls, field, enumToCls) |
560 if len(mustBe) > 0: | 528 if len(mustBe) > 0: |
561 for cnd in mustBe: | 529 for cnd in mustBe: |
562 if eval == '': | 530 if eval == '': |
563 eval = '(' + prop.fCppName + ' != ' + cnd.toCpp() + ')' | 531 eval = '(' + knowTypes[prop.fTypes.strip()][1] + ' != ' + cnd
.toCpp() + ')' |
564 else: | 532 else: |
565 eval = eval + ' && ' + '(' + prop.fCppName + ' != ' + cnd.toCp
p() + ')' | 533 eval = eval + ' && ' + '(' + knowTypes[prop.fTypes.strip()][1]
+ ' != ' + cnd.toCpp() + ')' |
566 fileMapperPodofoCpp.write(' if (' + eval + ') return false;\n') | 534 fileMapperNativeCpp.write(' if (' + eval + ') return false;\n') |
567 fileMapperPodofoCpp.write('\n') | 535 fileMapperNativeCpp.write('\n') |
568 | 536 |
569 fileMapperPodofoCpp.write(' return true;\n') | 537 fileMapperNativeCpp.write(' return true;\n') |
570 | 538 |
571 fileMapperPodofoCpp.write('}\n') | 539 fileMapperNativeCpp.write('}\n') |
572 fileMapperPodofoCpp.write('\n') | 540 fileMapperNativeCpp.write('\n') |
573 | 541 |
574 fileMapperPodofo.write(' bool SkPdf' + name + 'FromDictionary(const PoDoF
o::PdfDictionary& dict, const char* key, SkPdf' + name + '** data) const ;\n') | 542 # TODO(edisonn): dict should be a SkPdfDictionary ? |
575 fileMapperPodofoCpp.write('bool SkPdfMapper::SkPdf' + name + 'FromDictiona
ry(const PoDoFo::PdfDictionary& dict, const char* key, SkPdf' + name + '** data)
const {\n') | 543 fileMapperNative.write(' bool SkPdf' + name + 'FromDictionary(const SkPdf
Object* dict, const char* key, SkPdf' + name + '** data) const ;\n') |
576 fileMapperPodofoCpp.write(' const PoDoFo::PdfObject* value = resolveRefer
enceObject(fParsedDoc, dict.GetKey(PoDoFo::PdfName(key)), true);\n') | 544 fileMapperNativeCpp.write('bool SkPdfMapper::SkPdf' + name + 'FromDictiona
ry(const SkPdfObject* dict, const char* key, SkPdf' + name + '** data) const {\n
') |
577 fileMapperPodofoCpp.write(' if (value == NULL) { return false; }\n') | 545 fileMapperNativeCpp.write(' const SkPdfObject* value = dict->get(key);\n'
) |
578 fileMapperPodofoCpp.write(' if (data == NULL) { return true; }\n') | 546 fileMapperNativeCpp.write(' if (value == NULL) { return false; }\n') |
579 fileMapperPodofoCpp.write(' return map' + name + '(value, (SkPdf' + name
+ '**)data);\n') | 547 fileMapperNativeCpp.write(' if (data == NULL) { return true; }\n') |
580 fileMapperPodofoCpp.write('}\n') | 548 fileMapperNativeCpp.write(' if (kNone_SkPdfObjectType == map' + name + '(
value)) return false;\n') |
581 fileMapperPodofoCpp.write('\n') | 549 fileMapperNativeCpp.write(' *data = (SkPdf' + name + '*)value;\n') |
| 550 fileMapperNativeCpp.write(' return true;\n'); |
| 551 fileMapperNativeCpp.write('}\n') |
| 552 fileMapperNativeCpp.write('\n') |
582 | 553 |
583 fileMapperPodofo.write(' bool SkPdf' + name + 'FromDictionary(const PoDoF
o::PdfDictionary& dict, const char* key, const char* abr, SkPdf' + name + '** da
ta) const ;\n') | 554 fileMapperNative.write(' bool SkPdf' + name + 'FromDictionary(const SkPdf
Object* dict, const char* key, const char* abr, SkPdf' + name + '** data) const
;\n') |
584 fileMapperPodofoCpp.write('bool SkPdfMapper::SkPdf' + name + 'FromDictiona
ry(const PoDoFo::PdfDictionary& dict, const char* key, const char* abr, SkPdf' +
name + '** data) const {\n') | 555 fileMapperNativeCpp.write('bool SkPdfMapper::SkPdf' + name + 'FromDictiona
ry(const SkPdfObject* dict, const char* key, const char* abr, SkPdf' + name + '*
* data) const {\n') |
585 fileMapperPodofoCpp.write(' if (SkPdf' + name + 'FromDictionary(dict, key
, data)) return true;\n') | 556 fileMapperNativeCpp.write(' if (SkPdf' + name + 'FromDictionary(dict, key
, data)) return true;\n') |
586 fileMapperPodofoCpp.write(' if (abr == NULL || *abr == \'\\0\') return fa
lse;\n') | 557 fileMapperNativeCpp.write(' if (abr == NULL || *abr == \'\\0\') return fa
lse;\n') |
587 fileMapperPodofoCpp.write(' return SkPdf' + name + 'FromDictionary(dict,
abr, data);\n') | 558 fileMapperNativeCpp.write(' return SkPdf' + name + 'FromDictionary(dict,
abr, data);\n') |
588 fileMapperPodofoCpp.write('}\n') | 559 fileMapperNativeCpp.write('}\n') |
589 fileMapperPodofoCpp.write('\n') | 560 fileMapperNativeCpp.write('\n') |
590 | 561 |
591 fileMapperPodofo.write('};\n') | 562 fileMapperNative.write('};\n') |
592 fileMapperPodofo.write('\n') | 563 fileMapperNative.write('\n') |
593 | 564 |
594 fileMapperPodofo.write('#endif // __DEFINED__SkPdfMapper\n') | 565 fileMapperNative.write('#endif // __DEFINED__SkPdfMapper\n') |
595 | 566 |
596 fileMapperPodofo.close() | 567 fileMapperNative.close() |
597 fileMapperPodofoCpp.close() | 568 fileMapperNativeCpp.close() |
598 | 569 |
599 return | 570 return |
600 | 571 |
601 def generateCode(): | 572 def generateCode(): |
602 global fileHeadersPodofo | 573 global fileHeadersNative |
603 global fileHeadersPodofoCpp | 574 global fileHeadersNativeCpp |
604 global knowTypes | 575 global knowTypes |
605 | 576 |
606 fileHeadersPodofo = open(sys.argv[1] + 'podofo/autogen/SkPdfHeaders_autogen.h'
, 'w') | 577 fileHeadersNative = open(sys.argv[1] + 'native/autogen/SkPdfHeaders_autogen.h'
, 'w') |
607 fileHeadersPodofoCpp = open(sys.argv[1] + 'podofo/autogen/SkPdfHeaders_autogen
.cpp', 'w') | 578 fileHeadersNativeCpp = open(sys.argv[1] + 'native/autogen/SkPdfHeaders_autogen
.cpp', 'w') |
608 | 579 |
609 fileHeadersPodofo.write('#ifndef __DEFINED__SkPdfHeaders\n') | 580 fileHeadersNative.write('#ifndef __DEFINED__SkPdfHeaders\n') |
610 fileHeadersPodofo.write('#define __DEFINED__SkPdfHeaders\n') | 581 fileHeadersNative.write('#define __DEFINED__SkPdfHeaders\n') |
611 fileHeadersPodofo.write('\n') | 582 fileHeadersNative.write('\n') |
612 | 583 |
613 fileHeadersPodofoCpp.write('#include "SkPdfHeaders_autogen.h"\n') | 584 fileHeadersNativeCpp.write('#include "SkPdfHeaders_autogen.h"\n') |
614 | 585 |
615 manager = PdfClassManager() | 586 manager = PdfClassManager() |
616 | 587 |
617 manager.addClass('Object') | |
618 | |
619 # TODO(edisonn): perf, instead of virtual functions, store data in field and r
eurn it. | |
620 # maybe in constructor load it, or laizy load it | |
621 | |
622 manager.addClass('Null').check('podofoObj->GetDataType() == PoDoFo::ePdfDataTy
pe_Null') | |
623 manager.addClass('Boolean').check('podofoObj->GetDataType() == PoDoFo::ePdfDat
aType_Bool')\ | |
624 .carbonCopyPublicPodofo('bool value() const;')\ | |
625 .carbonCopyPublicPodofoCpp('bool SkPdfBoolean::valu
e() const {return podofo()->GetBool();}') | |
626 | |
627 manager.addClass('Integer').check('podofoObj->GetDataType() == PoDoFo::ePdfDat
aType_Number || podofoObj->GetDataType() == PoDoFo::ePdfDataType_Real')\ | |
628 .carbonCopyPublicPodofo('long value() const;')\ | |
629 .carbonCopyPublicPodofoCpp('long SkPdfInteger::valu
e() const {return podofo()->GetNumber();}') | |
630 | |
631 manager.addClass('Number', 'Integer').check('podofoObj->GetDataType() == PoDoF
o::ePdfDataType_Number || podofoObj->GetDataType() == PoDoFo::ePdfDataType_Real'
)\ | |
632 .carbonCopyPublicPodofo('double value() const;')\ | |
633 .carbonCopyPublicPodofoCpp('double SkPdfNumber::val
ue() const {return podofo()->GetReal();}')\ | |
634 | |
635 manager.addClass('Name').check('podofoObj->GetDataType() == PoDoFo::ePdfDataTy
pe_Name')\ | |
636 .carbonCopyPublicPodofo('const std::string& value()
const;')\ | |
637 .carbonCopyPublicPodofoCpp('const std::string& SkPd
fName::value() const {return podofo()->GetName().GetName();}') | |
638 | |
639 manager.addClass('Reference').check('podofoObj->GetDataType() == PoDoFo::ePdfD
ataType_Reference') | |
640 | |
641 manager.addClass('Array').check('podofoObj->GetDataType() == PoDoFo::ePdfDataT
ype_Array')\ | |
642 .carbonCopyPublicPodofo('int size() const;')\ | |
643 .carbonCopyPublicPodofoCpp('int SkPdfArray::size()
const {return podofo()->GetArray().GetSize();}')\ | |
644 .carbonCopyPublicPodofo('SkPdfObject* operator[](in
t i) const;')\ | |
645 .carbonCopyPublicPodofoCpp('SkPdfObject* SkPdfArray
::operator[](int i) const { SkPdfObject* ret = NULL; fParsedDoc->mapper()->mapO
bject(&podofo()->GetArray()[i], &ret); return ret; }') | |
646 | |
647 manager.addClass('String').check('podofoObj->GetDataType() == PoDoFo::ePdfData
Type_String || podofoObj->GetDataType() == PoDoFo::ePdfDataType_HexString')\ | |
648 .carbonCopyPublicPodofo('const std::string& value()
const;')\ | |
649 .carbonCopyPublicPodofoCpp('const std::string& SkPdf
String::value() const {return podofo()->GetString().GetStringUtf8();}')\ | |
650 .carbonCopyPublicPodofo('const char* c_str() const;'
)\ | |
651 .carbonCopyPublicPodofoCpp('const char* SkPdfString:
:c_str() const {return podofo()->GetString().GetString();}')\ | |
652 .carbonCopyPublicPodofo('size_t len() const;')\ | |
653 .carbonCopyPublicPodofoCpp('size_t SkPdfString::len(
) const {return podofo()->GetString().GetLength();}') | |
654 | |
655 manager.addClass('HexString', 'String').check('podofoObj->GetDataType() == PoD
oFo::ePdfDataType_HexString')\ | |
656 | |
657 manager.addClass('Dictionary').check('podofoObj->GetDataType() == PoDoFo::ePdf
DataType_Dictionary')\ | |
658 .carbonCopyPublicPodofo('SkPdfObject* get(const
char* dictionaryKeyName) const;')\ | |
659 .carbonCopyPublicPodofoCpp('SkPdfObject* SkPdfDi
ctionary::get(const char* dictionaryKeyName) const {SkPdfObject* ret = NULL; fPa
rsedDoc->mapper()->mapObject(resolveReferenceObject(fParsedDoc, podofo()->GetDic
tionary().GetKey(PoDoFo::PdfName(dictionaryKeyName))), &ret); return ret;}')\ | |
660 | |
661 # attached to a dictionary in podofo | |
662 manager.addClass('Stream')\ | |
663 .carbonCopyPublicPodofo('bool GetFilteredCopy(char** buffer, long*
len) const;')\ | |
664 .carbonCopyPublicPodofoCpp('bool SkPdfStream::GetFilteredCopy(char
** buffer, long* len) const {try {PoDoFo::pdf_long podofoLen = 0; *buffer = NULL
; *len = 0;podofo()->GetStream()->GetFilteredCopy(buffer, &podofoLen); *len = (l
ong)podofoLen;} catch (PoDoFo::PdfError& e) { return false; } return true;}') | |
665 | |
666 | |
667 # these classes are not explicitely backed by a table in the pdf spec | 588 # these classes are not explicitely backed by a table in the pdf spec |
| 589 manager.addClass('Dictionary') |
668 manager.addClass('XObjectDictionary', 'Dictionary') | 590 manager.addClass('XObjectDictionary', 'Dictionary') |
669 | 591 |
670 manager.addClass('FontDictionary', 'Dictionary') | 592 manager.addClass('FontDictionary', 'Dictionary') |
671 | 593 |
672 manager.addClass('TrueTypeFontDictionary', 'Type1FontDictionary')\ | 594 manager.addClass('TrueTypeFontDictionary', 'Type1FontDictionary')\ |
673 .required('NULL')\ | 595 .required('NULL')\ |
674 .field('Subtype')\ | 596 .field('Subtype')\ |
675 .name('Subtype')\ | 597 .name('Subtype')\ |
676 .type('name')\ | 598 .type('name')\ |
677 .comment('')\ | 599 .comment('')\ |
678 .must([datatypes.PdfName('TrueType')])\ | 600 .must([datatypes.PdfName('TrueType')])\ |
679 .done().done()\ | 601 .done().done()\ |
680 | 602 |
681 | |
682 addDictionaryTypesTo(knowTypes) | 603 addDictionaryTypesTo(knowTypes) |
683 buildPdfSpec(manager) | 604 buildPdfSpec(manager) |
684 | 605 |
685 manager.addClass('MultiMasterFontDictionary', 'Type1FontDictionary')\ | 606 manager.addClass('MultiMasterFontDictionary', 'Type1FontDictionary')\ |
686 .required('NULL')\ | 607 .required('NULL')\ |
687 .field('Subtype')\ | 608 .field('Subtype')\ |
688 .name('Subtype')\ | 609 .name('Subtype')\ |
689 .type('name')\ | 610 .type('name')\ |
690 .comment('')\ | 611 .comment('')\ |
691 .must([datatypes.PdfName('MMType1')])\ | 612 .must([datatypes.PdfName('MMType1')])\ |
692 .done().done()\ | 613 .done().done()\ |
693 | 614 |
694 | 615 |
695 manager.write() | 616 manager.write() |
696 | 617 |
697 fileHeadersPodofo.write('#endif // __DEFINED__SkPdfHeaders\n') | 618 fileHeadersNative.write('#endif // __DEFINED__SkPdfHeaders\n') |
698 | 619 |
699 fileHeadersPodofo.close() | 620 fileHeadersNative.close() |
700 fileHeadersPodofoCpp.close() | 621 fileHeadersNativeCpp.close() |
701 | 622 |
702 if '__main__' == __name__: | 623 if '__main__' == __name__: |
703 #print sys.argv | 624 #print sys.argv |
704 sys.exit(generateCode()) | 625 sys.exit(generateCode()) |
705 | 626 |
OLD | NEW |