| 81 |
81 |
warnno = 1
|
| 82 |
82 |
warncomment = "Undefined comment"
|
| 83 |
83 |
""" Implementation of the singleton interface """
|
| 84 |
|
def set_config(self, eoledirs=None, distrib_dir=None, conffile=None, dtddir=None):
|
|
84 |
def set_config(self, eoledirs=None, distrib_dir=None, conffile=None, \
|
|
85 |
dtddir=None):
|
| 85 |
86 |
if eoledirs != None and type(eoledirs) != list:
|
| 86 |
87 |
raise TypeError('eoledirs doit être une liste')
|
| 87 |
88 |
if distrib_dir != None and type(distrib_dir) != str:
|
| ... | ... | |
| 210 |
211 |
def _collect_vars_in_dicos(self):
|
| 211 |
212 |
if self.eoledirs == None or self.distrib_dir == None:
|
| 212 |
213 |
raise Exception('Utiliser la methode set_config avant')
|
| 213 |
|
dic = EoleDict(templatedir=self.distrib_dir, logfile='/dev/null', linter=True)
|
|
214 |
dic = EoleDict(templatedir=self.distrib_dir, logfile='/dev/null',
|
|
215 |
linter=True)
|
| 214 |
216 |
dic.read_dir(self.eoledirs)
|
| 215 |
217 |
return dic
|
| 216 |
218 |
|
| ... | ... | |
| 256 |
258 |
else:
|
| 257 |
259 |
dvar[var] = TmplVar(name=var, fd=fd, line=linenb)
|
| 258 |
260 |
|
| 259 |
|
def _collect_vars_in(self, expr, dvar, fd, linenb, exists=False):
|
| 260 |
|
varcreole = re.compile(varstarttoken+'([a-zA-Z0-9_\.{}]+)')
|
| 261 |
|
varcreole2 = re.compile(varstarttoken+'(\w+)')
|
| 262 |
|
varcreolebr = re.compile(varstarttoken+'{(\w+)}')
|
|
261 |
def _collect_vars_in(self, expr, dvar, fd, linenb, tvarstarttoken,
|
|
262 |
exists=False):
|
|
263 |
varcreole = re.compile(tvarstarttoken+'([a-zA-Z0-9_\.{}]+)')
|
|
264 |
varcreole2 = re.compile(tvarstarttoken+'(\w+)')
|
|
265 |
varcreolebr = re.compile(tvarstarttoken+'{(\w+)}')
|
| 263 |
266 |
varmulti = re.compile('(\w+)\.(\w+)')
|
| 264 |
267 |
for var in varcreole.findall(expr):
|
| 265 |
268 |
|
| ... | ... | |
| 270 |
273 |
self._collect_var_in(dvar, ret.group(2), fd, linenb, exists)
|
| 271 |
274 |
else:
|
| 272 |
275 |
#%%var
|
| 273 |
|
for var2 in varcreole2.findall(varstarttoken+var):
|
|
276 |
for var2 in varcreole2.findall(tvarstarttoken+var):
|
| 274 |
277 |
self._collect_var_in(dvar, var2, fd, linenb, exists)
|
| 275 |
278 |
#%%{var}
|
| 276 |
|
for var2 in varcreolebr.findall(varstarttoken+var):
|
|
279 |
for var2 in varcreolebr.findall(tvarstarttoken+var):
|
| 277 |
280 |
self._collect_var_in(dvar, var2, fd, linenb, exists)
|
| 278 |
281 |
|
| 279 |
282 |
def _collect_for_vars(self):
|
| 280 |
283 |
if self.forvars == None:
|
| 281 |
284 |
self.forvars = {}
|
| 282 |
285 |
self.brokenfor = []
|
| 283 |
|
pattern = re.compile(starttoken+'for (.+) in (.*)')
|
|
286 |
tpattern = 'for (.+) in (.*)'
|
|
287 |
tstarttoken = ''
|
|
288 |
tvarstarttoken = ''
|
| 284 |
289 |
for tmplfd in self._list_tmpl_files():
|
| 285 |
290 |
fh = open(tmplfd, 'r')
|
| 286 |
291 |
lines = fh.readlines()
|
| 287 |
292 |
length = len(lines)
|
|
293 |
settings = False
|
|
294 |
if tstarttoken != starttoken or \
|
|
295 |
tvarstarttoken != varstarttoken:
|
|
296 |
pattern = re.compile(starttoken+tpattern)
|
|
297 |
tstarttoken = starttoken
|
|
298 |
tvarstarttoken = varstarttoken
|
| 288 |
299 |
for linenb in range(length):
|
| 289 |
300 |
line = lines[linenb]
|
| 290 |
|
ret = pattern.match(line.strip())
|
| 291 |
|
if ret != None:
|
| 292 |
|
self._collect_vars_in(ret.group(1), self.forvars, tmplfd, linenb)
|
| 293 |
|
if ret.group(1).strip()[:2] != varstarttoken:
|
| 294 |
|
self.brokenfor.append(TmplVar(name=line.strip(), fd=tmplfd, line=linenb))
|
|
301 |
if line.strip() == '%compiler-settings':
|
|
302 |
settings = True
|
|
303 |
if settings and line.strip() == \
|
|
304 |
'%end compiler-settings'.strip():
|
|
305 |
settings = False
|
|
306 |
if not settings:
|
|
307 |
ret = pattern.match(line.strip())
|
|
308 |
if ret != None:
|
|
309 |
self._collect_vars_in(ret.group(1),
|
|
310 |
self.forvars, tmplfd, linenb,
|
|
311 |
tvarstarttoken)
|
|
312 |
if ret.group(1).strip()[:2] != tvarstarttoken:
|
|
313 |
self.brokenfor.append(TmplVar(
|
|
314 |
name=line.strip(),
|
|
315 |
fd=tmplfd, line=linenb))
|
|
316 |
else:
|
|
317 |
tline = line.split('=')
|
|
318 |
tkey = tline[0].strip()
|
|
319 |
if tkey == 'cheetahVarStartToken':
|
|
320 |
tvarstarttoken = tline[1].strip()
|
|
321 |
elif tkey == 'directiveStartToken':
|
|
322 |
tstarttoken = tline[1].strip()
|
|
323 |
pattern = re.compile(tstarttoken+tpattern)
|
| 295 |
324 |
|
| 296 |
325 |
fh.close()
|
| 297 |
326 |
|
| 298 |
327 |
def _collect_def_vars(self):
|
| 299 |
328 |
if self.defvars == None:
|
| 300 |
329 |
self.defvars = {}
|
| 301 |
|
pattern = re.compile(starttoken+'def (.*)\((.*)\)')
|
|
330 |
tpattern = 'def (.*)\((.*)\)'
|
|
331 |
tstarttoken = None
|
|
332 |
tvarstarttoken = None
|
| 302 |
333 |
for tmplfd in self._list_tmpl_files():
|
| 303 |
334 |
fh = open(tmplfd, 'r')
|
| 304 |
335 |
lines = fh.readlines()
|
| 305 |
336 |
length = len(lines)
|
|
337 |
settings = False
|
|
338 |
if tstarttoken != starttoken or \
|
|
339 |
tvarstarttoken != varstarttoken:
|
|
340 |
pattern = re.compile(starttoken+tpattern)
|
|
341 |
tstarttoken = starttoken
|
|
342 |
tvarstarttoken = varstarttoken
|
| 306 |
343 |
for linenb in range(length):
|
| 307 |
344 |
line = lines[linenb]
|
| 308 |
|
ret = pattern.match(line)
|
| 309 |
|
if ret != None:
|
| 310 |
|
self._collect_var_in(self.defvars, ret.group(1).strip(), tmplfd, linenb)
|
| 311 |
|
self._collect_vars_in(ret.group(2), self.defvars, tmplfd, linenb)
|
|
345 |
if line.strip() == '%compiler-settings':
|
|
346 |
settings = True
|
|
347 |
if settings and line.strip() == \
|
|
348 |
'%end compiler-settings'.strip():
|
|
349 |
settings = False
|
|
350 |
if not settings:
|
|
351 |
ret = pattern.match(line)
|
|
352 |
if ret != None:
|
|
353 |
self._collect_var_in(self.defvars,
|
|
354 |
ret.group(1).strip(), tmplfd, linenb)
|
|
355 |
self._collect_vars_in(ret.group(2),
|
|
356 |
self.defvars, tmplfd, linenb,
|
|
357 |
tvarstarttoken)
|
|
358 |
else:
|
|
359 |
tline = line.split('=')
|
|
360 |
tkey = tline[0].strip()
|
|
361 |
if tkey == 'cheetahVarStartToken':
|
|
362 |
tvarstarttoken = tline[1].strip()
|
|
363 |
elif tkey == 'directiveStartToken':
|
|
364 |
tstarttoken = tline[1].strip()
|
|
365 |
pattern = re.compile(tstarttoken+tpattern)
|
| 312 |
366 |
|
| 313 |
367 |
fh.close()
|
| 314 |
368 |
|
| 315 |
369 |
def _collect_set_vars(self):
|
| 316 |
370 |
if self.setvars == None:
|
| 317 |
371 |
self.setvars = {}
|
| 318 |
|
pattern = re.compile(starttoken+'set (.*)=.*')
|
|
372 |
tpattern = 'set (.*)=.*'
|
|
373 |
tstarttoken = None
|
|
374 |
tvarstarttoken = None
|
| 319 |
375 |
for tmplfd in self._list_tmpl_files():
|
| 320 |
376 |
if not isfile(tmplfd):
|
| 321 |
377 |
raise Exception('fichier template déclaré mais inexistant %s'%tmplfd)
|
| 322 |
378 |
fh = open(tmplfd, 'r')
|
| 323 |
379 |
lines = fh.readlines()
|
| 324 |
380 |
length = len(lines)
|
|
381 |
settings = False
|
|
382 |
if tstarttoken != starttoken or \
|
|
383 |
tvarstarttoken != varstarttoken:
|
|
384 |
pattern = re.compile(starttoken+tpattern)
|
|
385 |
tstarttoken = starttoken
|
|
386 |
tvarstarttoken = varstarttoken
|
| 325 |
387 |
for linenb in range(length):
|
| 326 |
388 |
line = lines[linenb]
|
| 327 |
|
ret = pattern.match(line)
|
| 328 |
|
if ret != None:
|
| 329 |
|
self._collect_vars_in(ret.group(1), self.setvars, tmplfd, linenb)
|
|
389 |
if line.strip() == '%compiler-settings':
|
|
390 |
settings = True
|
|
391 |
if settings and line.strip() == \
|
|
392 |
'%end compiler-settings'.strip():
|
|
393 |
settings = False
|
|
394 |
if not settings:
|
|
395 |
ret = pattern.match(line)
|
|
396 |
if ret != None:
|
|
397 |
self._collect_vars_in(ret.group(1),
|
|
398 |
self.setvars, tmplfd, linenb,
|
|
399 |
tvarstarttoken)
|
|
400 |
else:
|
|
401 |
tline = line.split('=')
|
|
402 |
tkey = tline[0].strip()
|
|
403 |
if tkey == 'cheetahVarStartToken':
|
|
404 |
tvarstarttoken = tline[1].strip()
|
|
405 |
elif tkey == 'directiveStartToken':
|
|
406 |
tstarttoken = tline[1].strip()
|
|
407 |
pattern = re.compile(tstarttoken+tpattern)
|
| 330 |
408 |
|
| 331 |
409 |
fh.close()
|
| 332 |
410 |
|
| 333 |
411 |
def _collect_define_vars(self):
|
| 334 |
412 |
if self.var_with_is_defined == None:
|
| 335 |
413 |
self.var_with_is_defined = {}
|
| 336 |
|
pattern = re.compile('%s(elif|if) %sis_defined\(\'(\w+)\'\) and'%(starttoken, varstarttoken))
|
|
414 |
tpattern = '%s(elif|if) %sis_defined\(\'(\w+)\'\) and'
|
|
415 |
tstarttoken = None
|
|
416 |
ttvarstarttoken = None
|
| 337 |
417 |
for tmplfd in self._list_tmpl_files():
|
| 338 |
418 |
fh = open(tmplfd, 'r')
|
| 339 |
419 |
lines = fh.readlines()
|
| 340 |
420 |
length = len(lines)
|
|
421 |
settings = False
|
|
422 |
if tstarttoken != starttoken or \
|
|
423 |
tvarstarttoken != varstarttoken:
|
|
424 |
pattern = re.compile(tpattern%(starttoken,
|
|
425 |
varstarttoken))
|
|
426 |
tstarttoken = starttoken
|
|
427 |
tvarstarttoken = varstarttoken
|
| 341 |
428 |
for linenb in range(length):
|
| 342 |
429 |
line = lines[linenb]
|
| 343 |
|
ret = pattern.match(line)
|
| 344 |
|
if ret != None:
|
| 345 |
|
self._collect_var_in(self.var_with_is_defined, ret.group(1), tmplfd, linenb)
|
|
430 |
if line.strip() == '%compiler-settings':
|
|
431 |
settings = True
|
|
432 |
if settings and line.strip() == \
|
|
433 |
'%end compiler-settings'.strip():
|
|
434 |
settings = False
|
|
435 |
if not settings:
|
|
436 |
ret = pattern.match(line)
|
|
437 |
if ret != None:
|
|
438 |
self._collect_var_in(self.var_with_is_defined,
|
|
439 |
ret.group(1), tmplfd, linenb)
|
|
440 |
else:
|
|
441 |
tline = line.split('=')
|
|
442 |
tkey = tline[0].strip()
|
|
443 |
if tkey == 'cheetahVarStartToken':
|
|
444 |
tvarstarttoken = tline[1].strip()
|
|
445 |
pattern = re.compile(tpattern%(tstarttoken,
|
|
446 |
tvarstarttoken))
|
|
447 |
elif tkey == 'directiveStartToken':
|
|
448 |
tstarttoken = tline[1].strip()
|
|
449 |
pattern = re.compile(tpattern%(tstarttoken,
|
|
450 |
tvarstarttoken))
|
| 346 |
451 |
fh.close()
|
| 347 |
452 |
|
| 348 |
453 |
def _collect_vars_in_tmplfiles(self):
|
| 349 |
454 |
if self.eoledirs == None or self.distrib_dir == None:
|
| 350 |
455 |
raise Exception('Utiliser la methode set_config avant')
|
| 351 |
456 |
# XXX ".eolvars" is a good placeholder for var names to be kept in touch
|
|
457 |
|
| 352 |
458 |
self.tmplvars = {}
|
| 353 |
459 |
for tmplfd in self._list_tmpl_files():
|
| 354 |
460 |
fh = open(tmplfd, 'r')
|
| 355 |
461 |
lines = fh.readlines()
|
| 356 |
462 |
length = len(lines)
|
|
463 |
settings = False
|
|
464 |
tvarstarttoken = varstarttoken
|
| 357 |
465 |
for linenb in range(length):
|
| 358 |
466 |
line = lines[linenb]
|
| 359 |
467 |
#FIXME: err
|
| 360 |
|
self._collect_vars_in(line, self.tmplvars, tmplfd, linenb, True)
|
|
468 |
if line.strip() == '%compiler-settings':
|
|
469 |
settings = True
|
|
470 |
if settings and line.strip() == \
|
|
471 |
'%end compiler-settings'.strip():
|
|
472 |
settings = False
|
|
473 |
if not settings:
|
|
474 |
self._collect_vars_in(line, self.tmplvars, tmplfd,
|
|
475 |
linenb, tvarstarttoken, True)
|
|
476 |
else:
|
|
477 |
tline = line.split('=')
|
|
478 |
tkey = tline[0].strip()
|
|
479 |
if tkey == 'cheetahVarStartToken':
|
|
480 |
tvarstarttoken = tline[1].strip()
|
|
481 |
#elif tkey == 'directiveStartToken':
|
|
482 |
# tstarttoken = tline[1].strip()
|
| 361 |
483 |
|
| 362 |
484 |
fh.close()
|
| 363 |
|
# XXX cheetahVarStartToken may redefine the beginswith variable
|
| 364 |
485 |
|
| 365 |
486 |
# storage for the instance reference
|
| 366 |
487 |
__instance = None
|