##// END OF EJS Templates
HG_REPOSITORIES » LPP » INSTRUMENTATION » kicadtools
RSS
Netlist parsing and loading ok, get in memory abstract syntax tree and concrete...
jeandet -
r2:096591f9de09 default
parent child
Show More
Show file before | Show file after | Hide comments
This diff has been collapsed as it changes many lines, (544 lines changed) Show them Hide them
@@ -1,200 +1,698
1 1 /*------------------------------------------------------------------------------
2 2 -- This file is a part of the Kicad Tools Software
3 3 -- Copyright (C) 2014, Plasma Physics Laboratory - CNRS
4 4 --
5 5 -- This program is free software; you can redistribute it and/or modify
6 6 -- it under the terms of the GNU General Public License as published by
7 7 -- the Free Software Foundation; either version 2 of the License, or
8 8 -- (at your option) any later version.
9 9 --
10 10 -- This program is distributed in the hope that it will be useful,
11 11 -- but WITHOUT ANY WARRANTY; without even the implied warranty of
12 12 -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 13 -- GNU General Public License for more details.
14 14 --
15 15 -- You should have received a copy of the GNU General Public License
16 16 -- along with this program; if not, write to the Free Software
17 17 -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18 18 -------------------------------------------------------------------------------*/
19 19 /*-- Author : Alexis Jeandet
20 20 -- Mail : alexis.jeandet@member.fsf.org
21 21 ----------------------------------------------------------------------------*/
22 22 #include "qicadnetlist.h"
23 23 #include <QRegularExpression>
24 24
25 25
26 26 const char* root_c ="(export";
27 27 const char* version_c ="(version";
28 28 const char* design_c ="(design";
29 29 const char* source_c ="(source";
30 30 const char* date_c ="(date";
31 31 const char* tool_c ="(tool";
32 32 const char* components_c ="(components";
33 33 const char* component_c ="(comp";
34 34 const char* ref_c ="(ref";
35 35 const char* value_c ="(value";
36 36 const char* libsource_c ="(libsource";
37 37 const char* lib_c ="(lib";
38 38 const char* part_c ="(part";
39 39 const char* sheetpath_c ="(sheetpath";
40 40 const char* names_c ="(names";
41 41 const char* tstamps_c ="(tstamps";
42 42 const char* tstamp_c ="(tstamp";
43 43 const char* libparts_c ="(libparts";
44 44 const char* libpart_c ="(libpart";
45 45 const char* fields_c ="(fields";
46 46 const char* field_c ="(field";
47 47 const char* name_c ="(name";
48 48 const char* pins_c ="(pins";
49 49 const char* pin_c ="(pin";
50 50 const char* num_c ="(num";
51 51 const char* type_c ="(type";
52 52 const char* libraries_c ="(libraries";
53 53 const char* library_c ="(library";
54 54 const char* logical_c ="(logical";
55 55 const char* uri_c ="(uri";
56 56 const char* nets_c ="(nets";
57 57 const char* net_c ="(net";
58 58 const char* code_c ="(code";
59 59 const char* node_c ="(node";
60 60
61 61
62 62 QIlib::QIcadNetList::QIcadNetList()
63 :netlistRoot(NULL)
63 64 {
64 65
65 66 }
66 67
67 68
68 69 bool QIlib::QIcadNetList::parseNetList(const QString &netlist)
69 70 {
70 71
71 72 parse(netlist.toStdString().c_str());
72 73 updateConcreteTree();
73 74 return false;
74 75 }
75 76
76 77 QString QIlib::QIcadNetList::print()
77 78 {
78 79 return rootNode.print();
79 80 }
80 81
81 82 QIlib::AbstractNode *QIlib::QIcadNetList::getAbstractNode(const QString &node, int index)
82 83 {
83 84 return getAbstractNode(&rootNode,node,&index);
84 85 }
85 86
86 87 QIlib::AbstractNode *QIlib::QIcadNetList::getAbstractNode(QIlib::AbstractNode *rootNode, const QString &node, int* index)
87 88 {
88 89 for(int i=0;i<rootNode->nodes.count();i++)
89 90 {
90 91 if(rootNode->nodes.at(i)->name==node)
91 92 {
92 93 if((*index)==0)
93 94 {
94 95 return rootNode->nodes.at(i);
95 96 }
96 97 (*index)-=1;
97 98 }
98 99 else
99 100 {
100 101 if(0<rootNode->nodes.at(i)->nodes.count())
101 102 {
102 103 QIlib::AbstractNode *result=getAbstractNode(rootNode->nodes.at(i),node,index);
103 104 if(NULL!=result)return result;
104 105 }
105 106 }
106 107 }
107 108 return NULL;
108 109 }
109 110
110 /*
111 QString version;
112 QIcadNetListDesign design;
113 QList<QIcadNetListComponent*> components;
114 QList<QIcadNetListLibPart*> libparts;
115 QIcadNetListLevel rootSheet;
116 */
117
118 #define setVal(dest,node,name,index) \
119 (node) = getAbstractNode((name),(index));\
120 if(((node)!=NULL)&&(0<(node)->Values.count())) \
121 {\
122 (dest) = (node)->Values.at(0); \
123 } \
124
125 111
126 112 void QIlib::QIcadNetList::updateConcreteTree()
127 113 {
128 QIlib::AbstractNode *node;
129 setVal(this->version,node,QIlib::Lexique::version_c,0);
130 setVal(this->design.date,node,QIlib::Lexique::date_c,0);
131 setVal(this->design.source,node,QIlib::Lexique::source_c,0);
132 setVal(this->design.tool,node,QIlib::Lexique::tool_c,0);
133 this->design.date.clear();
114 if(this->rootNode.nodes.count())
115 {
116 if(this->rootNode.nodes.at(0)->name==QIlib::Lexique::root_c)
117 {
118 if(this->netlistRoot==NULL)
119 {
120 this->netlistRoot = new QIcadNetListRoot(this->rootNode.nodes.at(0));
134 121 }
135
136
122 }
123 }
124 }
137 125
138 126
139 127
140 128 QIlib::QIcadAbstractNodeWrapper::QIcadAbstractNodeWrapper(AbstractNode *node)
141 129 {
142 130 this->p_node = node;
143 131 }
144 132
145 133 QIlib::QIcadAbstractNodeWrapper::~QIcadAbstractNodeWrapper()
146 134 {
147 135 /*First delete all the childs*/
148 136 for(int i=0;i<this->childs.count();i++)
149 137 {
150 138 if(this->childs.at(i))
151 139 delete this->childs.at(i);
152 140 }
153 141 }
154 142
155 143 QString QIlib::QIcadAbstractNodeWrapper::value()
156 144 {
157 145 if((p_node->Values.count()>0) && p_node)
158 146 return p_node->Values.at(0);
159 147 return QString("");
160 148 }
161 149
162 150 QString QIlib::QIcadAbstractNodeWrapper::value(int index)
163 151 {
164 152 if((p_node->Values.count()>index) && p_node)
165 153 return p_node->Values.at(index);
166 154 return QString("");
167 155 }
168 156
169 157 QString QIlib::QIcadAbstractNodeWrapper::catValues()
170 158 {
171 159 if(p_node)
172 160 {
173 161 QString result("");
174 162 for(int i=0;i<p_node->Values.count();i++)
175 163 {
176 164 result.append(p_node->Values.at(i));
177 165 }
178 166 return result;
179 167 }
180 168 }
181 169
182 170 void QIlib::QIcadAbstractNodeWrapper::setNode(QIlib::AbstractNode *node)
183 171 {
184 172 this->p_node = node;
185 173 }
186 174
187 175
188 176
189 177 QIlib::QIcadNetListRoot::QIcadNetListRoot(QIlib::AbstractNode *node)
190 178 :QIcadAbstractNodeWrapper(node)
191 179 {
180 this->setNode(node);
181 }
192 182
183 void QIlib::QIcadNetListRoot::setNode(QIlib::AbstractNode *node)
184 {
185 this->p_node = node;
186 if(node->name==QIlib::Lexique::root_c)
187 {
188 for(int i=0;i<node->nodes.count();i++)
189 {
190 if(node->nodes.at(i)->name==QIlib::Lexique::design_c)
191 {
192 this->design.setNode(node->nodes.at(i));
193 }
194 if(node->nodes.at(i)->name==QIlib::Lexique::components_c)
195 {
196 this->setComponents(node->nodes.at(i));
197 }
198 if(node->nodes.at(i)->name==QIlib::Lexique::libparts_c)
199 {
200 this->setLibParts(node->nodes.at(i));
201 }
202 if(node->nodes.at(i)->name==QIlib::Lexique::libraries_c)
203 {
204 this->setLibraries(node->nodes.at(i));
205 }
206 if(node->nodes.at(i)->name==QIlib::Lexique::nets_c)
207 {
208 this->setNets(node->nodes.at(i));
209 }
210 }
211 }
212 }
213
214 void QIlib::QIcadNetListRoot::setComponents(QIlib::AbstractNode *node)
215 {
216 while(components.count())
217 {
218 QIcadNetListComponent* component;
219 component = components.last();
220 components.removeLast();
221 delete component;
222 }
223 apendComponents(node);
224 }
225
226 void QIlib::QIcadNetListRoot::apendComponents(QIlib::AbstractNode *node)
227 {
228 if(node->name==QIlib::Lexique::components_c)
229 {
230 for(int i=0;i<node->nodes.count();i++)
231 {
232 if(node->nodes.at(i)->name==QIlib::Lexique::component_c)
233 {
234 this->components.append(new QIcadNetListComponent(node->nodes.at(i)));
235 }
236 }
237 }
238 }
239
240 void QIlib::QIcadNetListRoot::setLibParts(QIlib::AbstractNode *node)
241 {
242 while(libparts.count())
243 {
244 QIcadNetListLibPart* libpart;
245 libpart = libparts.last();
246 libparts.removeLast();
247 delete libpart;
248 }
249 apendLibParts(node);
250 }
251
252 void QIlib::QIcadNetListRoot::apendLibParts(QIlib::AbstractNode *node)
253 {
254 if(node->name==QIlib::Lexique::libparts_c)
255 {
256 for(int i=0;i<node->nodes.count();i++)
257 {
258 if(node->nodes.at(i)->name==QIlib::Lexique::libpart_c)
259 {
260 this->libparts.append(new QIcadNetListLibPart(node->nodes.at(i)));
261 }
262 }
263 }
264 }
265
266 void QIlib::QIcadNetListRoot::setLibraries(QIlib::AbstractNode *node)
267 {
268 while(libraries.count())
269 {
270 QIcadNetListLibrary* lib;
271 lib = libraries.last();
272 libraries.removeLast();
273 delete lib;
274 }
275 apendLibraries(node);
276 }
277
278 void QIlib::QIcadNetListRoot::apendLibraries(QIlib::AbstractNode *node)
279 {
280 if(node->name==QIlib::Lexique::libraries_c)
281 {
282 for(int i=0;i<node->nodes.count();i++)
283 {
284 if(node->nodes.at(i)->name==QIlib::Lexique::library_c)
285 {
286 this->libraries.append(new QIcadNetListLibrary(node->nodes.at(i)));
287 }
288 }
289 }
290 }
291
292 void QIlib::QIcadNetListRoot::setNets(QIlib::AbstractNode *node)
293 {
294 while(nets.count())
295 {
296 QIcadNetListNet* net;
297 net = nets.last();
298 nets.removeLast();
299 delete net;
300 }
301 apendNets(node);
302 }
303
304 void QIlib::QIcadNetListRoot::apendNets(QIlib::AbstractNode *node)
305 {
306 if(node->name==QIlib::Lexique::nets_c)
307 {
308 for(int i=0;i<node->nodes.count();i++)
309 {
310 if(node->nodes.at(i)->name==QIlib::Lexique::net_c)
311 {
312 this->nets.append(new QIcadNetListNet(node->nodes.at(i)));
313 }
314 }
315 }
193 316 }
194 317
195 318
196 319 QIlib::QIcadNetListComponent::QIcadNetListComponent(QIlib::AbstractNode *node)
197 320 :QIcadAbstractNodeWrapper(node)
198 321 {
322 setNode(node);
323 }
199 324
325 void QIlib::QIcadNetListComponent::setNode(QIlib::AbstractNode *node)
326 {
327 if(node->name==QIlib::Lexique::component_c)
328 {
329 for(int i=0;i<node->nodes.count();i++)
330 {
331 if(node->nodes.at(i)->name==QIlib::Lexique::ref_c)
332 {
333 this->ref.setNode(node->nodes.at(i));
200 334 }
335 if(node->nodes.at(i)->name==QIlib::Lexique::value_c)
336 {
337 this->value.setNode(node->nodes.at(i));
338 }
339 if(node->nodes.at(i)->name==QIlib::Lexique::libsource_c)
340 {
341 this->libsource.setNode(node->nodes.at(i));
342 }
343 if(node->nodes.at(i)->name==QIlib::Lexique::sheetpath_c)
344 {
345 this->sheetpath.setNode(node->nodes.at(i));
346 }
347 if(node->nodes.at(i)->name==QIlib::Lexique::tstamp_c)
348 {
349 this->tstamp.setNode(node->nodes.at(i));
350 }
351 }
352 }
353 }
354
355
356 QIlib::QIcadNetListDesign::QIcadNetListDesign(QIlib::AbstractNode *node)
357 :QIcadAbstractNodeWrapper(node)
358 {
359 this->setNode(node);
360 }
361
362 void QIlib::QIcadNetListDesign::setNode(QIlib::AbstractNode *node)
363 {
364 if(node->name==QIlib::Lexique::design_c)
365 {
366 this->p_node = node;
367 for(int i=0;i<node->nodes.count();i++)
368 {
369 if(node->nodes.at(i)->name==QIlib::Lexique::source_c)
370 {
371 this->source.setNode(node->nodes.at(i));
372 }
373 if(node->nodes.at(i)->name==QIlib::Lexique::date_c)
374 {
375 this->date.setNode(node->nodes.at(i));
376 }
377 if(node->nodes.at(i)->name==QIlib::Lexique::tool_c)
378 {
379 this->tool.setNode(node->nodes.at(i));
380 }
381 }
382 }
383 }
384
385 QIlib::QIcadNetListLibPart::QIcadNetListLibPart(QIlib::AbstractNode *node)
386 {
387 setNode(node);
388 }
389 /*
390 (libparts
391 (libpart (lib guan) (part 24L-MOD-8)
392 (fields
393 (field (name Reference) IC)
394 (field (name Value) 24L-MOD-8))
395 (pins
396 (pin (num 1) (name GND) (type power_in))
397 (pin (num 2) (name VCC) (type power_in))
398 */
399 void QIlib::QIcadNetListLibPart::setNode(QIlib::AbstractNode *node)
400 {
401 if(node->name==QIlib::Lexique::libpart_c)
402 {
403 this->p_node = node;
404 for(int i=0;i<node->nodes.count();i++)
405 {
406 if(node->nodes.at(i)->name==QIlib::Lexique::lib_c)
407 {
408 this->lib.setNode(node->nodes.at(i));
409 }
410 if(node->nodes.at(i)->name==QIlib::Lexique::part_c)
411 {
412 this->part.setNode(node->nodes.at(i));
413 }
414 if(node->nodes.at(i)->name==QIlib::Lexique::fields_c)
415 {
416 setFields(node->nodes.at(i));
417 }
418 if(node->nodes.at(i)->name==QIlib::Lexique::pins_c)
419 {
420 setPins(node->nodes.at(i));
421 }
422 }
423 }
424 }
425
426 void QIlib::QIcadNetListLibPart::setFields(QIlib::AbstractNode *node)
427 {
428 while(fields.count())
429 {
430 QIcadNetListField* field;
431 field = fields.last();
432 fields.removeLast();
433 delete field;
434 }
435 apendFields(node);
436 }
437
438 void QIlib::QIcadNetListLibPart::apendFields(QIlib::AbstractNode *node)
439 {
440 if(node->name==QIlib::Lexique::fields_c)
441 {
442 for(int i=0;i<node->nodes.count();i++)
443 {
444 if(node->nodes.at(i)->name==QIlib::Lexique::field_c)
445 {
446 this->fields.append(new QIcadNetListField(node->nodes.at(i)));
447 }
448 }
449 }
450 }
451
452 void QIlib::QIcadNetListLibPart::setPins(QIlib::AbstractNode *node)
453 {
454 while(pins.count())
455 {
456 QIcadNetListPin* pin;
457 pin = pins.last();
458 pins.removeLast();
459 delete pin;
460 }
461 apendPins(node);
462 }
463
464 void QIlib::QIcadNetListLibPart::apendPins(QIlib::AbstractNode *node)
465 {
466 if(node->name==QIlib::Lexique::pins_c)
467 {
468 for(int i=0;i<node->nodes.count();i++)
469 {
470 if(node->nodes.at(i)->name==QIlib::Lexique::pin_c)
471 {
472 this->pins.append(new QIcadNetListPin(node->nodes.at(i)));
473 }
474 }
475 }
476 }
477
478
479 QIlib::QIcadNetListLibrary::QIcadNetListLibrary(QIlib::AbstractNode *node)
480 {
481 setNode(node);
482 }
483
484 void QIlib::QIcadNetListLibrary::setNode(QIlib::AbstractNode *node)
485 {
486 /*
487 (library (logical guan)
488 (uri /home/guan/boards/guan.lib))
489 */
490 if(node->name==QIlib::Lexique::library_c)
491 {
492 this->p_node = node;
493 for(int i=0;i<node->nodes.count();i++)
494 {
495 if(node->nodes.at(i)->name==QIlib::Lexique::logical_c)
496 {
497 this->logical.setNode(node->nodes.at(i));
498 }
499 if(node->nodes.at(i)->name==QIlib::Lexique::uri_c)
500 {
501 this->uri.setNode(node->nodes.at(i));
502 }
503 }
504 }
505 }
506
507
508
509 QIlib::QIcadNetListField::QIcadNetListField(QIlib::AbstractNode *node)
510 {
511 setNode(node);
512 }
513
514 void QIlib::QIcadNetListField::setNode(QIlib::AbstractNode *node)
515 {
516 if(node->name==QIlib::Lexique::field_c)
517 {
518 this->p_node = node;
519 for(int i=0;i<node->nodes.count();i++)
520 {
521 if(node->nodes.at(i)->name==QIlib::Lexique::name_c)
522 {
523 this->name.setNode(node->nodes.at(i));
524 }
525 }
526 }
527 }
528
529
530 QIlib::QIcadNetListLibPart::QIcadNetListPin::QIcadNetListPin(QIlib::AbstractNode *node)
531 {
532 setNode(node);
533 }
534
535 void QIlib::QIcadNetListLibPart::QIcadNetListPin::setNode(QIlib::AbstractNode *node)
536 {
537 //(pin (num 1) (name GND) (type power_in))
538 if(node->name==QIlib::Lexique::pin_c)
539 {
540 this->p_node = node;
541 for(int i=0;i<node->nodes.count();i++)
542 {
543 if(node->nodes.at(i)->name==QIlib::Lexique::name_c)
544 {
545 this->name.setNode(node->nodes.at(i));
546 }
547 if(node->nodes.at(i)->name==QIlib::Lexique::num_c)
548 {
549 this->num.setNode(node->nodes.at(i));
550 }
551 if(node->nodes.at(i)->name==QIlib::Lexique::type_c)
552 {
553 this->type.setNode(node->nodes.at(i));
554 }
555 }
556 }
557 }
558
559 QIlib::QIcadNetListComponent::QIcadNetListLibSource::QIcadNetListLibSource(QIlib::AbstractNode *node)
560 {
561 setNode(node);
562 }
563
564 void QIlib::QIcadNetListComponent::QIcadNetListLibSource::setNode(QIlib::AbstractNode *node)
565 {
566 //(libsource (lib guan) (part 24L-MOD-8))
567 if(node->name==QIlib::Lexique::libsource_c)
568 {
569 this->p_node = node;
570 for(int i=0;i<node->nodes.count();i++)
571 {
572 if(node->nodes.at(i)->name==QIlib::Lexique::lib_c)
573 {
574 this->lib.setNode(node->nodes.at(i));
575 }
576 if(node->nodes.at(i)->name==QIlib::Lexique::part_c)
577 {
578 this->part.setNode(node->nodes.at(i));
579 }
580 }
581 }
582 }
583
584 QIlib::QIcadNetListComponent::QIcadNetListSheetPath::QIcadNetListSheetPath(QIlib::AbstractNode *node)
585 {
586 setNode(node);
587 }
588
589 void QIlib::QIcadNetListComponent::QIcadNetListSheetPath::setNode(QIlib::AbstractNode *node)
590 {
591 //(sheetpath (names /) (tstamps /))
592 if(node->name==QIlib::Lexique::sheetpath_c)
593 {
594 this->p_node = node;
595 for(int i=0;i<node->nodes.count();i++)
596 {
597 if(node->nodes.at(i)->name==QIlib::Lexique::names_c)
598 {
599 this->names.setNode(node->nodes.at(i));
600 }
601 if(node->nodes.at(i)->name==QIlib::Lexique::tstamps_c)
602 {
603 this->tstamps.setNode(node->nodes.at(i));
604 }
605 }
606 }
607 }
608
609 QIlib::QIcadNetListNet::QIcadNetListNet(QIlib::AbstractNode *node)
610 {
611 setNode(node);
612 }
613
614 void QIlib::QIcadNetListNet::setNode(QIlib::AbstractNode *node)
615 {
616 /*
617 (nets
618 (net (code 15) (name "")
619 (node (ref C4) (pin 1))
620 (node (ref U2) (pin 4)))
621 (net (code 16) (name GND)
622 (node (ref D1) (pin 2))
623 (node (ref C1) (pin 2))
624 (node (ref IC1) (pin 1))
625 */
626 if(node->name==QIlib::Lexique::net_c)
627 {
628 this->p_node = node;
629 while(NetNodes.count())
630 {
631 QIcadNetListNetNode* net;
632 net = NetNodes.last();
633 NetNodes.removeLast();
634 delete net;
635 }
636 for(int i=0;i<node->nodes.count();i++)
637 {
638 if(node->nodes.at(i)->name==QIlib::Lexique::name_c)
639 {
640 this->name.setNode(node->nodes.at(i));
641 }
642 if(node->nodes.at(i)->name==QIlib::Lexique::code_c)
643 {
644 this->code.setNode(node->nodes.at(i));
645 }
646 if(node->nodes.at(i)->name==QIlib::Lexique::node_c)
647 {
648 NetNodes.append(new QIcadNetListNetNode(node->nodes.at(i)));
649 }
650 }
651 }
652 }
653
654 QIlib::QIcadNetListNet::QIcadNetListNetNode::QIcadNetListNetNode(QIlib::AbstractNode *node)
655 {
656 setNode(node);
657 }
658
659 void QIlib::QIcadNetListNet::QIcadNetListNetNode::setNode(QIlib::AbstractNode *node)
660 {
661 //(node (ref D1) (pin 2))
662 if(node->name==QIlib::Lexique::node_c)
663 {
664 this->p_node = node;
665 for(int i=0;i<node->nodes.count();i++)
666 {
667 if(node->nodes.at(i)->name==QIlib::Lexique::ref_c)
668 {
669 this->ref.setNode(node->nodes.at(i));
670 }
671 if(node->nodes.at(i)->name==QIlib::Lexique::pin_c)
672 {
673 this->pin.setNode(node->nodes.at(i));
674 }
675 }
676 }
677 }
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
Show file before | Show file after | Hide comments
@@ -1,279 +1,268
1 1 #ifndef QICADNETLIST_H
2 2 #define QICADNETLIST_H
3 3 #include <QString>
4 4 #include <QStringList>
5 5 /*------------------------------------------------------------------------------
6 6 -- This file is a part of the Kicad Tools Software
7 7 -- Copyright (C) 2014, Plasma Physics Laboratory - CNRS
8 8 --
9 9 -- This program is free software; you can redistribute it and/or modify
10 10 -- it under the terms of the GNU General Public License as published by
11 11 -- the Free Software Foundation; either version 2 of the License, or
12 12 -- (at your option) any later version.
13 13 --
14 14 -- This program is distributed in the hope that it will be useful,
15 15 -- but WITHOUT ANY WARRANTY; without even the implied warranty of
16 16 -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 17 -- GNU General Public License for more details.
18 18 --
19 19 -- You should have received a copy of the GNU General Public License
20 20 -- along with this program; if not, write to the Free Software
21 21 -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 22 -------------------------------------------------------------------------------*/
23 23 /*-- Author : Alexis Jeandet
24 24 -- Mail : alexis.jeandet@member.fsf.org
25 25 ----------------------------------------------------------------------------*/
26 26 #include <QList>
27 27 #include <QFile>
28 28 #include <parsers/lispLike_driver.h>
29 29 #include <qicadnet.h>
30 30
31 31 namespace QIlib{
32 32
33 33 namespace Lexique
34 34 {
35 35 extern "C" const char* root_c ;
36 36 extern "C" const char* version_c ;
37 37 extern "C" const char* design_c ;
38 38 extern "C" const char* source_c ;
39 39 extern "C" const char* date_c ;
40 40 extern "C" const char* tool_c ;
41 41 extern "C" const char* components_c ;
42 42 extern "C" const char* component_c ;
43 43 extern "C" const char* ref_c ;
44 44 extern "C" const char* value_c ;
45 45 extern "C" const char* libsource_c ;
46 46 extern "C" const char* lib_c ;
47 47 extern "C" const char* part_c ;
48 48 extern "C" const char* sheetpath_c ;
49 49 extern "C" const char* names_c ;
50 50 extern "C" const char* tstamps_c ;
51 51 extern "C" const char* tstamp_c ;
52 52 extern "C" const char* libparts_c ;
53 53 extern "C" const char* libpart_c ;
54 54 extern "C" const char* fields_c ;
55 55 extern "C" const char* field_c ;
56 56 extern "C" const char* name_c ;
57 57 extern "C" const char* pins_c ;
58 58 extern "C" const char* pin_c ;
59 59 extern "C" const char* num_c ;
60 60 extern "C" const char* type_c ;
61 61 extern "C" const char* libraries_c ;
62 62 extern "C" const char* library_c ;
63 63 extern "C" const char* logical_c ;
64 64 extern "C" const char* uri_c ;
65 65 extern "C" const char* nets_c ;
66 66 extern "C" const char* net_c ;
67 67 extern "C" const char* code_c ;
68 68 extern "C" const char* node_c ;
69 69
70 70 }
71 71
72 class QIcadNetListLevel
73 {
74 public:
75 QIcadNetListLevel() {}
76 QList<QIcadNetListLevel*> sublevels;
77 QList<QIcadNet*> nets;
78 };
79 72
80 class QIcadNetListDesign
81 {
82 public:
83 QIcadNetListDesign(){}
84 QString source;
85 QString date;
86 QString tool;
87 };
88
89 class QIcadNetListComponent
90 {
91 public:
92 typedef struct libsource_t
93 {
94 QString lib;
95 QString part;
96 }libsource_t;
97 typedef struct sheetpath_t
98 {
99 QString names;
100 QString tstamp;
101 }sheetpath_t;
102 QIcadNetListComponent(){}
103 QString ref;
104 QString value;
105 QString tstamp;
106 libsource_t libsource;
107 sheetpath_t sheetpath;
108 };
109
110 class QIcadNetListLibPart
111 {
112 public:
113 typedef struct fields_t
114 {
115 QString ref;
116 QString value;
117 QString footprint;
118 QString datasheet;
119 }fields_t;
120 typedef struct pin_t
121 {
122 int num;
123 QString name;
124 QString type;
125 }pin_t;
126 QIcadNetListLibPart();
127 QString lib;
128 QString part;
129 QStringList footprints;
130 fields_t fields;
131 QList<pin_t*> pins;
132 };
133 73
134 74 class QIcadAbstractNodeWrapper
135 75 {
136 76 public:
137 77 QIcadAbstractNodeWrapper(QIlib::AbstractNode* node);
78 QIcadAbstractNodeWrapper(){}
138 79 ~QIcadAbstractNodeWrapper();
139 80 QString value();
140 81 QString value(int index);
141 82 QString catValues();
142 void setNode(QIlib::AbstractNode* node);
143 83 QList<QIcadAbstractNodeWrapper*> childs;
144 84 QIcadAbstractNodeWrapper* parent;
85 virtual void setNode(QIlib::AbstractNode* node);
145 86
146 private:
147 87 QIlib::AbstractNode* p_node;
148 88 };
149 89
150 class QIcadNetListRoot : public AbstractNode
90 class QIcadNetListDesign : public QIcadAbstractNodeWrapper
151 91 {
152 92 public:
153 QIcadNetListRoot(QIlib::AbstractNode* node);
93 QIcadNetListDesign(QIlib::AbstractNode* node);
94 QIcadNetListDesign(){}
154 95 QIcadAbstractNodeWrapper source;
155 96 QIcadAbstractNodeWrapper date;
156 97 QIcadAbstractNodeWrapper tool;
157 QList<QIcadNetListComponent*> components;
158 QList<QIcadNetListLibPart*> libparts;
159 QList<QIcadNetListLibrary*> libraries;
98 void setNode(QIlib::AbstractNode* node);
160 99 };
161 100
162 101
102
163 103 /*
164 104 * (comp (ref IC1)
165 105 (value 24L-MOD-8)
166 106 (libsource (lib guan) (part 24L-MOD-8))
167 107 (sheetpath (names /) (tstamps /))
168 108 (tstamp 52533BBE))
169 109 */
170 110 class QIcadNetListComponent:public QIcadAbstractNodeWrapper
171 111 {
112 class QIcadNetListLibSource : QIcadAbstractNodeWrapper
113 {
114 public:
115 QIcadNetListLibSource(AbstractNode* node);
116 QIcadNetListLibSource(){}
117 QIcadAbstractNodeWrapper lib;
118 QIcadAbstractNodeWrapper part;
119 void setNode(AbstractNode* node);
120 };
121 class QIcadNetListSheetPath : QIcadAbstractNodeWrapper
122 {
123 public:
124 QIcadNetListSheetPath(AbstractNode* node);
125 QIcadNetListSheetPath(){}
126 QIcadAbstractNodeWrapper names;
127 QIcadAbstractNodeWrapper tstamps;
128 void setNode(AbstractNode* node);
129 };
172 130 public:
173 131 QIcadNetListComponent(AbstractNode* node);
174 132 QIcadAbstractNodeWrapper ref;
175 133 QIcadAbstractNodeWrapper value;
176 QIcadAbstractNodeWrapper libsource;
177 QIcadAbstractNodeWrapper sheetpath;
134 QIcadNetListLibSource libsource;
135 QIcadNetListSheetPath sheetpath;
178 136 QIcadAbstractNodeWrapper tstamp;
137 void setNode(QIlib::AbstractNode* node);
179 138 };
180 139
181 140
182 141 /*
183 142 (libparts
184 143 (libpart (lib guan) (part 24L-MOD-8)
185 144 (fields
186 145 (field (name Reference) IC)
187 146 (field (name Value) 24L-MOD-8))
188 147 (pins
189 148 (pin (num 1) (name GND) (type power_in))
190 149 (pin (num 2) (name VCC) (type power_in))
191 150 */
192 151 class QIcadNetListField : QIcadAbstractNodeWrapper
193 152 {
194 153 public:
195 154 QIcadNetListField(AbstractNode* node);
196 155 QIcadAbstractNodeWrapper name;
156 void setNode(AbstractNode* node);
197 157 };
198 158
199 159
200 160 class QIcadNetListLibPart : QIcadAbstractNodeWrapper
201 161 {
202 162 class QIcadNetListPin : QIcadAbstractNodeWrapper
203 163 {
204 164 public:
205 165 QIcadNetListPin(AbstractNode* node);
206 166 QIcadAbstractNodeWrapper type;
207 167 QIcadAbstractNodeWrapper num;
208 168 QIcadAbstractNodeWrapper name;
169 void setNode(AbstractNode* node);
209 170 };
210 171 public:
211 172 QIcadNetListLibPart(AbstractNode* node);
173 QIcadAbstractNodeWrapper lib;
174 QIcadAbstractNodeWrapper part;
212 175 QList<QIcadNetListField*> fields;
213 176 QList<QIcadNetListPin*> pins;
177 void setNode(AbstractNode* node);
178 void setFields(QIlib::AbstractNode* node);
179 void apendFields(QIlib::AbstractNode* node);
180 void setPins(QIlib::AbstractNode* node);
181 void apendPins(QIlib::AbstractNode* node);
214 182 };
215 183
216 184 /*
217 185 (libraries
218 186 (library (logical guan)
219 187 (uri /home/guan/boards/guan.lib))
220 188 (library (logical device)
221 189 (uri /usr/share/kicad/library/device.lib))
222 190 (library (logical conn)
223 191 (uri /usr/share/kicad/library/conn.lib)))
224 192 */
225 193
226 194 class QIcadNetListLibrary : QIcadAbstractNodeWrapper
227 195 {
228 196 public:
229 197 QIcadNetListLibrary(AbstractNode* node);
230 198 QIcadAbstractNodeWrapper uri;
199 QIcadAbstractNodeWrapper logical;
200 void setNode(AbstractNode* node);
231 201 };
232 202 /*
233 203 (nets
234 204 (net (code 15) (name "")
235 205 (node (ref C4) (pin 1))
236 206 (node (ref U2) (pin 4)))
237 207 (net (code 16) (name GND)
238 208 (node (ref D1) (pin 2))
239 209 (node (ref C1) (pin 2))
240 210 (node (ref IC1) (pin 1))
241 211 */
242 212
243 213 class QIcadNetListNet : QIcadAbstractNodeWrapper
244 214 {
245 215 class QIcadNetListNetNode: QIcadAbstractNodeWrapper
246 216 {
247 217 public:
248 218 QIcadNetListNetNode(AbstractNode* node);
249 219 QIcadAbstractNodeWrapper ref;
250 220 QIcadAbstractNodeWrapper pin;
221 void setNode(AbstractNode* node);
251 222 };
252 223 public:
253 224 QIcadNetListNet(AbstractNode* node);
254 225 QList<QIcadNetListNetNode*> NetNodes;
226 QIcadAbstractNodeWrapper code;
227 QIcadAbstractNodeWrapper name;
228 void setNode(AbstractNode* node);
229
255 230 };
256 231
232 class QIcadNetListRoot : public QIcadAbstractNodeWrapper
233 {
234 public:
235 QIcadNetListRoot(QIlib::AbstractNode* node);
236 QIcadNetListDesign design;
237 QList<QIcadNetListComponent*> components;
238 QList<QIcadNetListLibPart*> libparts;
239 QList<QIcadNetListLibrary*> libraries;
240 QList<QIcadNetListNet*> nets;
241 void setNode(QIlib::AbstractNode* node);
242 void setComponents(QIlib::AbstractNode* node);
243 void apendComponents(QIlib::AbstractNode* node);
244 void setLibParts(QIlib::AbstractNode* node);
245 void apendLibParts(QIlib::AbstractNode* node);
246 void setLibraries(QIlib::AbstractNode* node);
247 void apendLibraries(QIlib::AbstractNode* node);
248 void setNets(QIlib::AbstractNode* node);
249 void apendNets(QIlib::AbstractNode* node);
250 };
257 251
258 252
259 253 class QIcadNetList : private lispLike_Driver
260 254 {
261 255 public:
262 256 QIcadNetList();
263 257 bool parseNetList(const QString& netlist);
264 258 QString toString();
265 259 QString fileName;
266 QString version;
267 QIcadNetListDesign design;
268 QList<QIcadNetListComponent*> components;
269 QList<QIcadNetListLibPart*> libparts;
270 QIcadNetListLevel rootSheet;
271 260 QString print();
272 QIcadAbstractNodeWrapper netlistRoot;
261 QIcadNetListRoot* netlistRoot;
273 262 private:
274 263 QIlib::AbstractNode* getAbstractNode(const QString& node,int index);
275 264 QIlib::AbstractNode* getAbstractNode(QIlib::AbstractNode* rootNode,const QString& node,int* index);
276 265 void updateConcreteTree();
277 266 };
278 267 }
279 268 #endif // QICADNETLIST_H
Show file before | Show file after | Hide comments
@@ -1,48 +1,59
1 1 /*------------------------------------------------------------------------------
2 2 -- This file is a part of the Kicad Tools Software
3 3 -- Copyright (C) 2014, Plasma Physics Laboratory - CNRS
4 4 --
5 5 -- This program is free software; you can redistribute it and/or modify
6 6 -- it under the terms of the GNU General Public License as published by
7 7 -- the Free Software Foundation; either version 2 of the License, or
8 8 -- (at your option) any later version.
9 9 --
10 10 -- This program is distributed in the hope that it will be useful,
11 11 -- but WITHOUT ANY WARRANTY; without even the implied warranty of
12 12 -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 13 -- GNU General Public License for more details.
14 14 --
15 15 -- You should have received a copy of the GNU General Public License
16 16 -- along with this program; if not, write to the Free Software
17 17 -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18 18 -------------------------------------------------------------------------------*/
19 19 /*-- Author : Alexis Jeandet
20 20 -- Mail : alexis.jeandet@member.fsf.org
21 21 ----------------------------------------------------------------------------*/
22 22 #include <QDir>
23 23 #include <QFile>
24 24 #include <QApplication>
25 25 #include <qicadnetlist.h>
26 26 #include <QDebug>
27 27 #include <QTime>
28 28 /*
29 29 #include <lispLike_driver.h>
30 30 */
31 31
32 32 int main(int argc, char *argv[])
33 33 {
34 34 QApplication ap(argc,argv);
35 35 QIlib::QIcadNetList NetListdriver;
36 36 if(argc>1)
37 37 {
38 38 if(QFile::exists(argv[1]))
39 39 {
40 40 QTime tm;
41 41 tm.start();
42 42 NetListdriver.parseNetList(argv[1]);
43 43 qDebug()<<"File parsed in "<<tm.elapsed()<<"ms";
44 if(ap.arguments().contains("--print"))
45 {
44 46 std::cout<<NetListdriver.print().toStdString();
45 47 }
48 else
49 {
50 for(int i=0;i<NetListdriver.netlistRoot->nets.count();i++)
51 {
52 std::cout<<"Found net:"<<NetListdriver.netlistRoot->nets.at(i)->name.value().toStdString()<<" "<<NetListdriver.netlistRoot->nets.at(i)->code.value().toStdString()<<"\n";
53 }
54 }
55 }
56
46 57 }
47 58 return 0;
48 59 }
General Comments 0
You need to be logged in to leave comments. Login now