Gitiles
Code Review Sign In
gerrit-public.fairphone.software / platform / external / python / cpython2 / 3e0055f8c65c407e74ce476b8e2b1fb889723514 / . / Python / Python-ast.c
blob: e82b61c96c8cc6a593210cd2a8a6300794e2f5a3 [file] [log] [blame]
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000[diff] [blame^]1/* File automatically generated by ../Parser/asdl_c.py */
2
3#include "Python.h"
4#include "Python-ast.h"
5
6mod_ty
7Module(asdl_seq * body)
8{
9 mod_ty p;
10 p = (mod_ty)malloc(sizeof(*p));
11 if (!p) {
12 PyErr_SetString(PyExc_MemoryError, "no memory");
13 return NULL;
14 }
15 p->kind = Module_kind;
16 p->v.Module.body = body;
17 return p;
18}
19
20mod_ty
21Interactive(asdl_seq * body)
22{
23 mod_ty p;
24 p = (mod_ty)malloc(sizeof(*p));
25 if (!p) {
26 PyErr_SetString(PyExc_MemoryError, "no memory");
27 return NULL;
28 }
29 p->kind = Interactive_kind;
30 p->v.Interactive.body = body;
31 return p;
32}
33
34mod_ty
35Expression(expr_ty body)
36{
37 mod_ty p;
38 if (!body) {
39 PyErr_SetString(PyExc_ValueError,
40 "field body is required for Expression");
41 return NULL;
42 }
43 p = (mod_ty)malloc(sizeof(*p));
44 if (!p) {
45 PyErr_SetString(PyExc_MemoryError, "no memory");
46 return NULL;
47 }
48 p->kind = Expression_kind;
49 p->v.Expression.body = body;
50 return p;
51}
52
53mod_ty
54Suite(asdl_seq * body)
55{
56 mod_ty p;
57 p = (mod_ty)malloc(sizeof(*p));
58 if (!p) {
59 PyErr_SetString(PyExc_MemoryError, "no memory");
60 return NULL;
61 }
62 p->kind = Suite_kind;
63 p->v.Suite.body = body;
64 return p;
65}
66
67stmt_ty
68FunctionDef(identifier name, arguments_ty args, asdl_seq * body, asdl_seq *
69 decorators, int lineno)
70{
71 stmt_ty p;
72 if (!name) {
73 PyErr_SetString(PyExc_ValueError,
74 "field name is required for FunctionDef");
75 return NULL;
76 }
77 if (!args) {
78 PyErr_SetString(PyExc_ValueError,
79 "field args is required for FunctionDef");
80 return NULL;
81 }
82 p = (stmt_ty)malloc(sizeof(*p));
83 if (!p) {
84 PyErr_SetString(PyExc_MemoryError, "no memory");
85 return NULL;
86 }
87 p->kind = FunctionDef_kind;
88 p->v.FunctionDef.name = name;
89 p->v.FunctionDef.args = args;
90 p->v.FunctionDef.body = body;
91 p->v.FunctionDef.decorators = decorators;
92 p->lineno = lineno;
93 return p;
94}
95
96stmt_ty
97ClassDef(identifier name, asdl_seq * bases, asdl_seq * body, int lineno)
98{
99 stmt_ty p;
100 if (!name) {
101 PyErr_SetString(PyExc_ValueError,
102 "field name is required for ClassDef");
103 return NULL;
104 }
105 p = (stmt_ty)malloc(sizeof(*p));
106 if (!p) {
107 PyErr_SetString(PyExc_MemoryError, "no memory");
108 return NULL;
109 }
110 p->kind = ClassDef_kind;
111 p->v.ClassDef.name = name;
112 p->v.ClassDef.bases = bases;
113 p->v.ClassDef.body = body;
114 p->lineno = lineno;
115 return p;
116}
117
118stmt_ty
119Return(expr_ty value, int lineno)
120{
121 stmt_ty p;
122 p = (stmt_ty)malloc(sizeof(*p));
123 if (!p) {
124 PyErr_SetString(PyExc_MemoryError, "no memory");
125 return NULL;
126 }
127 p->kind = Return_kind;
128 p->v.Return.value = value;
129 p->lineno = lineno;
130 return p;
131}
132
133stmt_ty
134Delete(asdl_seq * targets, int lineno)
135{
136 stmt_ty p;
137 p = (stmt_ty)malloc(sizeof(*p));
138 if (!p) {
139 PyErr_SetString(PyExc_MemoryError, "no memory");
140 return NULL;
141 }
142 p->kind = Delete_kind;
143 p->v.Delete.targets = targets;
144 p->lineno = lineno;
145 return p;
146}
147
148stmt_ty
149Assign(asdl_seq * targets, expr_ty value, int lineno)
150{
151 stmt_ty p;
152 if (!value) {
153 PyErr_SetString(PyExc_ValueError,
154 "field value is required for Assign");
155 return NULL;
156 }
157 p = (stmt_ty)malloc(sizeof(*p));
158 if (!p) {
159 PyErr_SetString(PyExc_MemoryError, "no memory");
160 return NULL;
161 }
162 p->kind = Assign_kind;
163 p->v.Assign.targets = targets;
164 p->v.Assign.value = value;
165 p->lineno = lineno;
166 return p;
167}
168
169stmt_ty
170AugAssign(expr_ty target, operator_ty op, expr_ty value, int lineno)
171{
172 stmt_ty p;
173 if (!target) {
174 PyErr_SetString(PyExc_ValueError,
175 "field target is required for AugAssign");
176 return NULL;
177 }
178 if (!op) {
179 PyErr_SetString(PyExc_ValueError,
180 "field op is required for AugAssign");
181 return NULL;
182 }
183 if (!value) {
184 PyErr_SetString(PyExc_ValueError,
185 "field value is required for AugAssign");
186 return NULL;
187 }
188 p = (stmt_ty)malloc(sizeof(*p));
189 if (!p) {
190 PyErr_SetString(PyExc_MemoryError, "no memory");
191 return NULL;
192 }
193 p->kind = AugAssign_kind;
194 p->v.AugAssign.target = target;
195 p->v.AugAssign.op = op;
196 p->v.AugAssign.value = value;
197 p->lineno = lineno;
198 return p;
199}
200
201stmt_ty
202Print(expr_ty dest, asdl_seq * values, bool nl, int lineno)
203{
204 stmt_ty p;
205 p = (stmt_ty)malloc(sizeof(*p));
206 if (!p) {
207 PyErr_SetString(PyExc_MemoryError, "no memory");
208 return NULL;
209 }
210 p->kind = Print_kind;
211 p->v.Print.dest = dest;
212 p->v.Print.values = values;
213 p->v.Print.nl = nl;
214 p->lineno = lineno;
215 return p;
216}
217
218stmt_ty
219For(expr_ty target, expr_ty iter, asdl_seq * body, asdl_seq * orelse, int
220 lineno)
221{
222 stmt_ty p;
223 if (!target) {
224 PyErr_SetString(PyExc_ValueError,
225 "field target is required for For");
226 return NULL;
227 }
228 if (!iter) {
229 PyErr_SetString(PyExc_ValueError,
230 "field iter is required for For");
231 return NULL;
232 }
233 p = (stmt_ty)malloc(sizeof(*p));
234 if (!p) {
235 PyErr_SetString(PyExc_MemoryError, "no memory");
236 return NULL;
237 }
238 p->kind = For_kind;
239 p->v.For.target = target;
240 p->v.For.iter = iter;
241 p->v.For.body = body;
242 p->v.For.orelse = orelse;
243 p->lineno = lineno;
244 return p;
245}
246
247stmt_ty
248While(expr_ty test, asdl_seq * body, asdl_seq * orelse, int lineno)
249{
250 stmt_ty p;
251 if (!test) {
252 PyErr_SetString(PyExc_ValueError,
253 "field test is required for While");
254 return NULL;
255 }
256 p = (stmt_ty)malloc(sizeof(*p));
257 if (!p) {
258 PyErr_SetString(PyExc_MemoryError, "no memory");
259 return NULL;
260 }
261 p->kind = While_kind;
262 p->v.While.test = test;
263 p->v.While.body = body;
264 p->v.While.orelse = orelse;
265 p->lineno = lineno;
266 return p;
267}
268
269stmt_ty
270If(expr_ty test, asdl_seq * body, asdl_seq * orelse, int lineno)
271{
272 stmt_ty p;
273 if (!test) {
274 PyErr_SetString(PyExc_ValueError,
275 "field test is required for If");
276 return NULL;
277 }
278 p = (stmt_ty)malloc(sizeof(*p));
279 if (!p) {
280 PyErr_SetString(PyExc_MemoryError, "no memory");
281 return NULL;
282 }
283 p->kind = If_kind;
284 p->v.If.test = test;
285 p->v.If.body = body;
286 p->v.If.orelse = orelse;
287 p->lineno = lineno;
288 return p;
289}
290
291stmt_ty
292Raise(expr_ty type, expr_ty inst, expr_ty tback, int lineno)
293{
294 stmt_ty p;
295 p = (stmt_ty)malloc(sizeof(*p));
296 if (!p) {
297 PyErr_SetString(PyExc_MemoryError, "no memory");
298 return NULL;
299 }
300 p->kind = Raise_kind;
301 p->v.Raise.type = type;
302 p->v.Raise.inst = inst;
303 p->v.Raise.tback = tback;
304 p->lineno = lineno;
305 return p;
306}
307
308stmt_ty
309TryExcept(asdl_seq * body, asdl_seq * handlers, asdl_seq * orelse, int lineno)
310{
311 stmt_ty p;
312 p = (stmt_ty)malloc(sizeof(*p));
313 if (!p) {
314 PyErr_SetString(PyExc_MemoryError, "no memory");
315 return NULL;
316 }
317 p->kind = TryExcept_kind;
318 p->v.TryExcept.body = body;
319 p->v.TryExcept.handlers = handlers;
320 p->v.TryExcept.orelse = orelse;
321 p->lineno = lineno;
322 return p;
323}
324
325stmt_ty
326TryFinally(asdl_seq * body, asdl_seq * finalbody, int lineno)
327{
328 stmt_ty p;
329 p = (stmt_ty)malloc(sizeof(*p));
330 if (!p) {
331 PyErr_SetString(PyExc_MemoryError, "no memory");
332 return NULL;
333 }
334 p->kind = TryFinally_kind;
335 p->v.TryFinally.body = body;
336 p->v.TryFinally.finalbody = finalbody;
337 p->lineno = lineno;
338 return p;
339}
340
341stmt_ty
342Assert(expr_ty test, expr_ty msg, int lineno)
343{
344 stmt_ty p;
345 if (!test) {
346 PyErr_SetString(PyExc_ValueError,
347 "field test is required for Assert");
348 return NULL;
349 }
350 p = (stmt_ty)malloc(sizeof(*p));
351 if (!p) {
352 PyErr_SetString(PyExc_MemoryError, "no memory");
353 return NULL;
354 }
355 p->kind = Assert_kind;
356 p->v.Assert.test = test;
357 p->v.Assert.msg = msg;
358 p->lineno = lineno;
359 return p;
360}
361
362stmt_ty
363Import(asdl_seq * names, int lineno)
364{
365 stmt_ty p;
366 p = (stmt_ty)malloc(sizeof(*p));
367 if (!p) {
368 PyErr_SetString(PyExc_MemoryError, "no memory");
369 return NULL;
370 }
371 p->kind = Import_kind;
372 p->v.Import.names = names;
373 p->lineno = lineno;
374 return p;
375}
376
377stmt_ty
378ImportFrom(identifier module, asdl_seq * names, int lineno)
379{
380 stmt_ty p;
381 if (!module) {
382 PyErr_SetString(PyExc_ValueError,
383 "field module is required for ImportFrom");
384 return NULL;
385 }
386 p = (stmt_ty)malloc(sizeof(*p));
387 if (!p) {
388 PyErr_SetString(PyExc_MemoryError, "no memory");
389 return NULL;
390 }
391 p->kind = ImportFrom_kind;
392 p->v.ImportFrom.module = module;
393 p->v.ImportFrom.names = names;
394 p->lineno = lineno;
395 return p;
396}
397
398stmt_ty
399Exec(expr_ty body, expr_ty globals, expr_ty locals, int lineno)
400{
401 stmt_ty p;
402 if (!body) {
403 PyErr_SetString(PyExc_ValueError,
404 "field body is required for Exec");
405 return NULL;
406 }
407 p = (stmt_ty)malloc(sizeof(*p));
408 if (!p) {
409 PyErr_SetString(PyExc_MemoryError, "no memory");
410 return NULL;
411 }
412 p->kind = Exec_kind;
413 p->v.Exec.body = body;
414 p->v.Exec.globals = globals;
415 p->v.Exec.locals = locals;
416 p->lineno = lineno;
417 return p;
418}
419
420stmt_ty
421Global(asdl_seq * names, int lineno)
422{
423 stmt_ty p;
424 p = (stmt_ty)malloc(sizeof(*p));
425 if (!p) {
426 PyErr_SetString(PyExc_MemoryError, "no memory");
427 return NULL;
428 }
429 p->kind = Global_kind;
430 p->v.Global.names = names;
431 p->lineno = lineno;
432 return p;
433}
434
435stmt_ty
436Expr(expr_ty value, int lineno)
437{
438 stmt_ty p;
439 if (!value) {
440 PyErr_SetString(PyExc_ValueError,
441 "field value is required for Expr");
442 return NULL;
443 }
444 p = (stmt_ty)malloc(sizeof(*p));
445 if (!p) {
446 PyErr_SetString(PyExc_MemoryError, "no memory");
447 return NULL;
448 }
449 p->kind = Expr_kind;
450 p->v.Expr.value = value;
451 p->lineno = lineno;
452 return p;
453}
454
455stmt_ty
456Pass(int lineno)
457{
458 stmt_ty p;
459 p = (stmt_ty)malloc(sizeof(*p));
460 if (!p) {
461 PyErr_SetString(PyExc_MemoryError, "no memory");
462 return NULL;
463 }
464 p->kind = Pass_kind;
465 p->lineno = lineno;
466 return p;
467}
468
469stmt_ty
470Break(int lineno)
471{
472 stmt_ty p;
473 p = (stmt_ty)malloc(sizeof(*p));
474 if (!p) {
475 PyErr_SetString(PyExc_MemoryError, "no memory");
476 return NULL;
477 }
478 p->kind = Break_kind;
479 p->lineno = lineno;
480 return p;
481}
482
483stmt_ty
484Continue(int lineno)
485{
486 stmt_ty p;
487 p = (stmt_ty)malloc(sizeof(*p));
488 if (!p) {
489 PyErr_SetString(PyExc_MemoryError, "no memory");
490 return NULL;
491 }
492 p->kind = Continue_kind;
493 p->lineno = lineno;
494 return p;
495}
496
497expr_ty
498BoolOp(boolop_ty op, asdl_seq * values, int lineno)
499{
500 expr_ty p;
501 if (!op) {
502 PyErr_SetString(PyExc_ValueError,
503 "field op is required for BoolOp");
504 return NULL;
505 }
506 p = (expr_ty)malloc(sizeof(*p));
507 if (!p) {
508 PyErr_SetString(PyExc_MemoryError, "no memory");
509 return NULL;
510 }
511 p->kind = BoolOp_kind;
512 p->v.BoolOp.op = op;
513 p->v.BoolOp.values = values;
514 p->lineno = lineno;
515 return p;
516}
517
518expr_ty
519BinOp(expr_ty left, operator_ty op, expr_ty right, int lineno)
520{
521 expr_ty p;
522 if (!left) {
523 PyErr_SetString(PyExc_ValueError,
524 "field left is required for BinOp");
525 return NULL;
526 }
527 if (!op) {
528 PyErr_SetString(PyExc_ValueError,
529 "field op is required for BinOp");
530 return NULL;
531 }
532 if (!right) {
533 PyErr_SetString(PyExc_ValueError,
534 "field right is required for BinOp");
535 return NULL;
536 }
537 p = (expr_ty)malloc(sizeof(*p));
538 if (!p) {
539 PyErr_SetString(PyExc_MemoryError, "no memory");
540 return NULL;
541 }
542 p->kind = BinOp_kind;
543 p->v.BinOp.left = left;
544 p->v.BinOp.op = op;
545 p->v.BinOp.right = right;
546 p->lineno = lineno;
547 return p;
548}
549
550expr_ty
551UnaryOp(unaryop_ty op, expr_ty operand, int lineno)
552{
553 expr_ty p;
554 if (!op) {
555 PyErr_SetString(PyExc_ValueError,
556 "field op is required for UnaryOp");
557 return NULL;
558 }
559 if (!operand) {
560 PyErr_SetString(PyExc_ValueError,
561 "field operand is required for UnaryOp");
562 return NULL;
563 }
564 p = (expr_ty)malloc(sizeof(*p));
565 if (!p) {
566 PyErr_SetString(PyExc_MemoryError, "no memory");
567 return NULL;
568 }
569 p->kind = UnaryOp_kind;
570 p->v.UnaryOp.op = op;
571 p->v.UnaryOp.operand = operand;
572 p->lineno = lineno;
573 return p;
574}
575
576expr_ty
577Lambda(arguments_ty args, expr_ty body, int lineno)
578{
579 expr_ty p;
580 if (!args) {
581 PyErr_SetString(PyExc_ValueError,
582 "field args is required for Lambda");
583 return NULL;
584 }
585 if (!body) {
586 PyErr_SetString(PyExc_ValueError,
587 "field body is required for Lambda");
588 return NULL;
589 }
590 p = (expr_ty)malloc(sizeof(*p));
591 if (!p) {
592 PyErr_SetString(PyExc_MemoryError, "no memory");
593 return NULL;
594 }
595 p->kind = Lambda_kind;
596 p->v.Lambda.args = args;
597 p->v.Lambda.body = body;
598 p->lineno = lineno;
599 return p;
600}
601
602expr_ty
603Dict(asdl_seq * keys, asdl_seq * values, int lineno)
604{
605 expr_ty p;
606 p = (expr_ty)malloc(sizeof(*p));
607 if (!p) {
608 PyErr_SetString(PyExc_MemoryError, "no memory");
609 return NULL;
610 }
611 p->kind = Dict_kind;
612 p->v.Dict.keys = keys;
613 p->v.Dict.values = values;
614 p->lineno = lineno;
615 return p;
616}
617
618expr_ty
619ListComp(expr_ty elt, asdl_seq * generators, int lineno)
620{
621 expr_ty p;
622 if (!elt) {
623 PyErr_SetString(PyExc_ValueError,
624 "field elt is required for ListComp");
625 return NULL;
626 }
627 p = (expr_ty)malloc(sizeof(*p));
628 if (!p) {
629 PyErr_SetString(PyExc_MemoryError, "no memory");
630 return NULL;
631 }
632 p->kind = ListComp_kind;
633 p->v.ListComp.elt = elt;
634 p->v.ListComp.generators = generators;
635 p->lineno = lineno;
636 return p;
637}
638
639expr_ty
640GeneratorExp(expr_ty elt, asdl_seq * generators, int lineno)
641{
642 expr_ty p;
643 if (!elt) {
644 PyErr_SetString(PyExc_ValueError,
645 "field elt is required for GeneratorExp");
646 return NULL;
647 }
648 p = (expr_ty)malloc(sizeof(*p));
649 if (!p) {
650 PyErr_SetString(PyExc_MemoryError, "no memory");
651 return NULL;
652 }
653 p->kind = GeneratorExp_kind;
654 p->v.GeneratorExp.elt = elt;
655 p->v.GeneratorExp.generators = generators;
656 p->lineno = lineno;
657 return p;
658}
659
660expr_ty
661Yield(expr_ty value, int lineno)
662{
663 expr_ty p;
664 p = (expr_ty)malloc(sizeof(*p));
665 if (!p) {
666 PyErr_SetString(PyExc_MemoryError, "no memory");
667 return NULL;
668 }
669 p->kind = Yield_kind;
670 p->v.Yield.value = value;
671 p->lineno = lineno;
672 return p;
673}
674
675expr_ty
676Compare(expr_ty left, asdl_seq * ops, asdl_seq * comparators, int lineno)
677{
678 expr_ty p;
679 if (!left) {
680 PyErr_SetString(PyExc_ValueError,
681 "field left is required for Compare");
682 return NULL;
683 }
684 p = (expr_ty)malloc(sizeof(*p));
685 if (!p) {
686 PyErr_SetString(PyExc_MemoryError, "no memory");
687 return NULL;
688 }
689 p->kind = Compare_kind;
690 p->v.Compare.left = left;
691 p->v.Compare.ops = ops;
692 p->v.Compare.comparators = comparators;
693 p->lineno = lineno;
694 return p;
695}
696
697expr_ty
698Call(expr_ty func, asdl_seq * args, asdl_seq * keywords, expr_ty starargs,
699 expr_ty kwargs, int lineno)
700{
701 expr_ty p;
702 if (!func) {
703 PyErr_SetString(PyExc_ValueError,
704 "field func is required for Call");
705 return NULL;
706 }
707 p = (expr_ty)malloc(sizeof(*p));
708 if (!p) {
709 PyErr_SetString(PyExc_MemoryError, "no memory");
710 return NULL;
711 }
712 p->kind = Call_kind;
713 p->v.Call.func = func;
714 p->v.Call.args = args;
715 p->v.Call.keywords = keywords;
716 p->v.Call.starargs = starargs;
717 p->v.Call.kwargs = kwargs;
718 p->lineno = lineno;
719 return p;
720}
721
722expr_ty
723Repr(expr_ty value, int lineno)
724{
725 expr_ty p;
726 if (!value) {
727 PyErr_SetString(PyExc_ValueError,
728 "field value is required for Repr");
729 return NULL;
730 }
731 p = (expr_ty)malloc(sizeof(*p));
732 if (!p) {
733 PyErr_SetString(PyExc_MemoryError, "no memory");
734 return NULL;
735 }
736 p->kind = Repr_kind;
737 p->v.Repr.value = value;
738 p->lineno = lineno;
739 return p;
740}
741
742expr_ty
743Num(object n, int lineno)
744{
745 expr_ty p;
746 if (!n) {
747 PyErr_SetString(PyExc_ValueError,
748 "field n is required for Num");
749 return NULL;
750 }
751 p = (expr_ty)malloc(sizeof(*p));
752 if (!p) {
753 PyErr_SetString(PyExc_MemoryError, "no memory");
754 return NULL;
755 }
756 p->kind = Num_kind;
757 p->v.Num.n = n;
758 p->lineno = lineno;
759 return p;
760}
761
762expr_ty
763Str(string s, int lineno)
764{
765 expr_ty p;
766 if (!s) {
767 PyErr_SetString(PyExc_ValueError,
768 "field s is required for Str");
769 return NULL;
770 }
771 p = (expr_ty)malloc(sizeof(*p));
772 if (!p) {
773 PyErr_SetString(PyExc_MemoryError, "no memory");
774 return NULL;
775 }
776 p->kind = Str_kind;
777 p->v.Str.s = s;
778 p->lineno = lineno;
779 return p;
780}
781
782expr_ty
783Attribute(expr_ty value, identifier attr, expr_context_ty ctx, int lineno)
784{
785 expr_ty p;
786 if (!value) {
787 PyErr_SetString(PyExc_ValueError,
788 "field value is required for Attribute");
789 return NULL;
790 }
791 if (!attr) {
792 PyErr_SetString(PyExc_ValueError,
793 "field attr is required for Attribute");
794 return NULL;
795 }
796 if (!ctx) {
797 PyErr_SetString(PyExc_ValueError,
798 "field ctx is required for Attribute");
799 return NULL;
800 }
801 p = (expr_ty)malloc(sizeof(*p));
802 if (!p) {
803 PyErr_SetString(PyExc_MemoryError, "no memory");
804 return NULL;
805 }
806 p->kind = Attribute_kind;
807 p->v.Attribute.value = value;
808 p->v.Attribute.attr = attr;
809 p->v.Attribute.ctx = ctx;
810 p->lineno = lineno;
811 return p;
812}
813
814expr_ty
815Subscript(expr_ty value, slice_ty slice, expr_context_ty ctx, int lineno)
816{
817 expr_ty p;
818 if (!value) {
819 PyErr_SetString(PyExc_ValueError,
820 "field value is required for Subscript");
821 return NULL;
822 }
823 if (!slice) {
824 PyErr_SetString(PyExc_ValueError,
825 "field slice is required for Subscript");
826 return NULL;
827 }
828 if (!ctx) {
829 PyErr_SetString(PyExc_ValueError,
830 "field ctx is required for Subscript");
831 return NULL;
832 }
833 p = (expr_ty)malloc(sizeof(*p));
834 if (!p) {
835 PyErr_SetString(PyExc_MemoryError, "no memory");
836 return NULL;
837 }
838 p->kind = Subscript_kind;
839 p->v.Subscript.value = value;
840 p->v.Subscript.slice = slice;
841 p->v.Subscript.ctx = ctx;
842 p->lineno = lineno;
843 return p;
844}
845
846expr_ty
847Name(identifier id, expr_context_ty ctx, int lineno)
848{
849 expr_ty p;
850 if (!id) {
851 PyErr_SetString(PyExc_ValueError,
852 "field id is required for Name");
853 return NULL;
854 }
855 if (!ctx) {
856 PyErr_SetString(PyExc_ValueError,
857 "field ctx is required for Name");
858 return NULL;
859 }
860 p = (expr_ty)malloc(sizeof(*p));
861 if (!p) {
862 PyErr_SetString(PyExc_MemoryError, "no memory");
863 return NULL;
864 }
865 p->kind = Name_kind;
866 p->v.Name.id = id;
867 p->v.Name.ctx = ctx;
868 p->lineno = lineno;
869 return p;
870}
871
872expr_ty
873List(asdl_seq * elts, expr_context_ty ctx, int lineno)
874{
875 expr_ty p;
876 if (!ctx) {
877 PyErr_SetString(PyExc_ValueError,
878 "field ctx is required for List");
879 return NULL;
880 }
881 p = (expr_ty)malloc(sizeof(*p));
882 if (!p) {
883 PyErr_SetString(PyExc_MemoryError, "no memory");
884 return NULL;
885 }
886 p->kind = List_kind;
887 p->v.List.elts = elts;
888 p->v.List.ctx = ctx;
889 p->lineno = lineno;
890 return p;
891}
892
893expr_ty
894Tuple(asdl_seq * elts, expr_context_ty ctx, int lineno)
895{
896 expr_ty p;
897 if (!ctx) {
898 PyErr_SetString(PyExc_ValueError,
899 "field ctx is required for Tuple");
900 return NULL;
901 }
902 p = (expr_ty)malloc(sizeof(*p));
903 if (!p) {
904 PyErr_SetString(PyExc_MemoryError, "no memory");
905 return NULL;
906 }
907 p->kind = Tuple_kind;
908 p->v.Tuple.elts = elts;
909 p->v.Tuple.ctx = ctx;
910 p->lineno = lineno;
911 return p;
912}
913
914slice_ty
915Ellipsis()
916{
917 slice_ty p;
918 p = (slice_ty)malloc(sizeof(*p));
919 if (!p) {
920 PyErr_SetString(PyExc_MemoryError, "no memory");
921 return NULL;
922 }
923 p->kind = Ellipsis_kind;
924 return p;
925}
926
927slice_ty
928Slice(expr_ty lower, expr_ty upper, expr_ty step)
929{
930 slice_ty p;
931 p = (slice_ty)malloc(sizeof(*p));
932 if (!p) {
933 PyErr_SetString(PyExc_MemoryError, "no memory");
934 return NULL;
935 }
936 p->kind = Slice_kind;
937 p->v.Slice.lower = lower;
938 p->v.Slice.upper = upper;
939 p->v.Slice.step = step;
940 return p;
941}
942
943slice_ty
944ExtSlice(asdl_seq * dims)
945{
946 slice_ty p;
947 p = (slice_ty)malloc(sizeof(*p));
948 if (!p) {
949 PyErr_SetString(PyExc_MemoryError, "no memory");
950 return NULL;
951 }
952 p->kind = ExtSlice_kind;
953 p->v.ExtSlice.dims = dims;
954 return p;
955}
956
957slice_ty
958Index(expr_ty value)
959{
960 slice_ty p;
961 if (!value) {
962 PyErr_SetString(PyExc_ValueError,
963 "field value is required for Index");
964 return NULL;
965 }
966 p = (slice_ty)malloc(sizeof(*p));
967 if (!p) {
968 PyErr_SetString(PyExc_MemoryError, "no memory");
969 return NULL;
970 }
971 p->kind = Index_kind;
972 p->v.Index.value = value;
973 return p;
974}
975
976comprehension_ty
977comprehension(expr_ty target, expr_ty iter, asdl_seq * ifs)
978{
979 comprehension_ty p;
980 if (!target) {
981 PyErr_SetString(PyExc_ValueError,
982 "field target is required for comprehension");
983 return NULL;
984 }
985 if (!iter) {
986 PyErr_SetString(PyExc_ValueError,
987 "field iter is required for comprehension");
988 return NULL;
989 }
990 p = (comprehension_ty)malloc(sizeof(*p));
991 if (!p) {
992 PyErr_SetString(PyExc_MemoryError, "no memory");
993 return NULL;
994 }
995 p->target = target;
996 p->iter = iter;
997 p->ifs = ifs;
998 return p;
999}
1000
1001excepthandler_ty
1002excepthandler(expr_ty type, expr_ty name, asdl_seq * body)
1003{
1004 excepthandler_ty p;
1005 p = (excepthandler_ty)malloc(sizeof(*p));
1006 if (!p) {
1007 PyErr_SetString(PyExc_MemoryError, "no memory");
1008 return NULL;
1009 }
1010 p->type = type;
1011 p->name = name;
1012 p->body = body;
1013 return p;
1014}
1015
1016arguments_ty
1017arguments(asdl_seq * args, identifier vararg, identifier kwarg, asdl_seq *
1018 defaults)
1019{
1020 arguments_ty p;
1021 p = (arguments_ty)malloc(sizeof(*p));
1022 if (!p) {
1023 PyErr_SetString(PyExc_MemoryError, "no memory");
1024 return NULL;
1025 }
1026 p->args = args;
1027 p->vararg = vararg;
1028 p->kwarg = kwarg;
1029 p->defaults = defaults;
1030 return p;
1031}
1032
1033keyword_ty
1034keyword(identifier arg, expr_ty value)
1035{
1036 keyword_ty p;
1037 if (!arg) {
1038 PyErr_SetString(PyExc_ValueError,
1039 "field arg is required for keyword");
1040 return NULL;
1041 }
1042 if (!value) {
1043 PyErr_SetString(PyExc_ValueError,
1044 "field value is required for keyword");
1045 return NULL;
1046 }
1047 p = (keyword_ty)malloc(sizeof(*p));
1048 if (!p) {
1049 PyErr_SetString(PyExc_MemoryError, "no memory");
1050 return NULL;
1051 }
1052 p->arg = arg;
1053 p->value = value;
1054 return p;
1055}
1056
1057alias_ty
1058alias(identifier name, identifier asname)
1059{
1060 alias_ty p;
1061 if (!name) {
1062 PyErr_SetString(PyExc_ValueError,
1063 "field name is required for alias");
1064 return NULL;
1065 }
1066 p = (alias_ty)malloc(sizeof(*p));
1067 if (!p) {
1068 PyErr_SetString(PyExc_MemoryError, "no memory");
1069 return NULL;
1070 }
1071 p->name = name;
1072 p->asname = asname;
1073 return p;
1074}
1075
1076static void
1077free_seq_exprs(asdl_seq *seq)
1078{
1079 int i, n;
1080 n = asdl_seq_LEN(seq);
1081 for (i = 0; i < n; i++)
1082 free_expr((expr_ty)asdl_seq_GET(seq, i));
1083 asdl_seq_free(seq);
1084}
1085
1086static void
1087free_seq_stmts(asdl_seq *seq)
1088{
1089 int i, n;
1090 n = asdl_seq_LEN(seq);
1091 for (i = 0; i < n; i++)
1092 free_stmt((stmt_ty)asdl_seq_GET(seq, i));
1093 asdl_seq_free(seq);
1094}
1095
1096void
1097free_mod(mod_ty o)
1098{
1099 if (!o)
1100 return;
1101
1102 switch (o->kind) {
1103 case Module_kind:
1104 free_seq_stmts(o->v.Module.body);
1105 break;
1106 case Interactive_kind:
1107 free_seq_stmts(o->v.Interactive.body);
1108 break;
1109 case Expression_kind:
1110 free_expr((expr_ty)o->v.Expression.body);
1111 break;
1112 case Suite_kind:
1113 free_seq_stmts(o->v.Suite.body);
1114 break;
1115 }
1116
1117 free(o);
1118}
1119
1120void
1121free_stmt(stmt_ty o)
1122{
1123 int i, n;
1124 asdl_seq *seq;
1125
1126 if (!o)
1127 return;
1128
1129 switch (o->kind) {
1130 case FunctionDef_kind:
1131 Py_DECREF((identifier)o->v.FunctionDef.name);
1132 free_arguments((arguments_ty)o->v.FunctionDef.args);
1133 free_seq_stmts(o->v.FunctionDef.body);
1134 free_seq_exprs(o->v.FunctionDef.decorators);
1135 break;
1136 case ClassDef_kind:
1137 Py_DECREF((identifier)o->v.ClassDef.name);
1138 free_seq_exprs(o->v.ClassDef.bases);
1139 free_seq_stmts(o->v.ClassDef.body);
1140 break;
1141 case Return_kind:
1142 if (o->v.Return.value) {
1143 free_expr((expr_ty)o->v.Return.value);
1144 }
1145 break;
1146 case Delete_kind:
1147 free_seq_exprs(o->v.Delete.targets);
1148 break;
1149 case Assign_kind:
1150 free_seq_exprs(o->v.Assign.targets);
1151 free_expr((expr_ty)o->v.Assign.value);
1152 break;
1153 case AugAssign_kind:
1154 free_expr((expr_ty)o->v.AugAssign.target);
1155 free_operator((operator_ty)o->v.AugAssign.op);
1156 free_expr((expr_ty)o->v.AugAssign.value);
1157 break;
1158 case Print_kind:
1159 if (o->v.Print.dest) {
1160 free_expr((expr_ty)o->v.Print.dest);
1161 }
1162 free_seq_exprs(o->v.Print.values);
1163 break;
1164 case For_kind:
1165 free_expr((expr_ty)o->v.For.target);
1166 free_expr((expr_ty)o->v.For.iter);
1167 free_seq_stmts(o->v.For.body);
1168 free_seq_stmts(o->v.For.orelse);
1169 break;
1170 case While_kind:
1171 free_expr((expr_ty)o->v.While.test);
1172 free_seq_stmts(o->v.While.body);
1173 free_seq_stmts(o->v.While.orelse);
1174 break;
1175 case If_kind:
1176 free_expr((expr_ty)o->v.If.test);
1177 free_seq_stmts(o->v.If.body);
1178 free_seq_stmts(o->v.If.orelse);
1179 break;
1180 case Raise_kind:
1181 if (o->v.Raise.type) {
1182 free_expr((expr_ty)o->v.Raise.type);
1183 }
1184 if (o->v.Raise.inst) {
1185 free_expr((expr_ty)o->v.Raise.inst);
1186 }
1187 if (o->v.Raise.tback) {
1188 free_expr((expr_ty)o->v.Raise.tback);
1189 }
1190 break;
1191 case TryExcept_kind:
1192 free_seq_stmts(o->v.TryExcept.body);
1193 seq = o->v.TryExcept.handlers;
1194 n = asdl_seq_LEN(seq);
1195 for (i = 0; i < n; i++)
1196 free_excepthandler((excepthandler_ty)asdl_seq_GET(seq,
1197 i));
1198 asdl_seq_free(seq);
1199 free_seq_stmts(o->v.TryExcept.orelse);
1200 break;
1201 case TryFinally_kind:
1202 free_seq_stmts(o->v.TryFinally.body);
1203 free_seq_stmts(o->v.TryFinally.finalbody);
1204 break;
1205 case Assert_kind:
1206 free_expr((expr_ty)o->v.Assert.test);
1207 if (o->v.Assert.msg) {
1208 free_expr((expr_ty)o->v.Assert.msg);
1209 }
1210 break;
1211 case Import_kind:
1212 seq = o->v.Import.names;
1213 n = asdl_seq_LEN(seq);
1214 for (i = 0; i < n; i++)
1215 free_alias((alias_ty)asdl_seq_GET(seq, i));
1216 asdl_seq_free(seq);
1217 break;
1218 case ImportFrom_kind:
1219 Py_DECREF((identifier)o->v.ImportFrom.module);
1220 seq = o->v.ImportFrom.names;
1221 n = asdl_seq_LEN(seq);
1222 for (i = 0; i < n; i++)
1223 free_alias((alias_ty)asdl_seq_GET(seq, i));
1224 asdl_seq_free(seq);
1225 break;
1226 case Exec_kind:
1227 free_expr((expr_ty)o->v.Exec.body);
1228 if (o->v.Exec.globals) {
1229 free_expr((expr_ty)o->v.Exec.globals);
1230 }
1231 if (o->v.Exec.locals) {
1232 free_expr((expr_ty)o->v.Exec.locals);
1233 }
1234 break;
1235 case Global_kind:
1236 seq = o->v.Global.names;
1237 n = asdl_seq_LEN(seq);
1238 for (i = 0; i < n; i++)
1239 Py_DECREF((identifier)asdl_seq_GET(seq, i));
1240 asdl_seq_free(seq);
1241 break;
1242 case Expr_kind:
1243 free_expr((expr_ty)o->v.Expr.value);
1244 break;
1245 case Pass_kind:
1246 break;
1247 case Break_kind:
1248 break;
1249 case Continue_kind:
1250 break;
1251 }
1252
1253 free(o);
1254}
1255
1256void
1257free_expr(expr_ty o)
1258{
1259 int i, n;
1260 asdl_seq *seq;
1261
1262 if (!o)
1263 return;
1264
1265 switch (o->kind) {
1266 case BoolOp_kind:
1267 free_boolop((boolop_ty)o->v.BoolOp.op);
1268 free_seq_exprs(o->v.BoolOp.values);
1269 break;
1270 case BinOp_kind:
1271 free_expr((expr_ty)o->v.BinOp.left);
1272 free_operator((operator_ty)o->v.BinOp.op);
1273 free_expr((expr_ty)o->v.BinOp.right);
1274 break;
1275 case UnaryOp_kind:
1276 free_unaryop((unaryop_ty)o->v.UnaryOp.op);
1277 free_expr((expr_ty)o->v.UnaryOp.operand);
1278 break;
1279 case Lambda_kind:
1280 free_arguments((arguments_ty)o->v.Lambda.args);
1281 free_expr((expr_ty)o->v.Lambda.body);
1282 break;
1283 case Dict_kind:
1284 free_seq_exprs(o->v.Dict.keys);
1285 free_seq_exprs(o->v.Dict.values);
1286 break;
1287 case ListComp_kind:
1288 free_expr((expr_ty)o->v.ListComp.elt);
1289 seq = o->v.ListComp.generators;
1290 n = asdl_seq_LEN(seq);
1291 for (i = 0; i < n; i++)
1292 free_comprehension((comprehension_ty)asdl_seq_GET(seq,
1293 i));
1294 asdl_seq_free(seq);
1295 break;
1296 case GeneratorExp_kind:
1297 free_expr((expr_ty)o->v.GeneratorExp.elt);
1298 seq = o->v.GeneratorExp.generators;
1299 n = asdl_seq_LEN(seq);
1300 for (i = 0; i < n; i++)
1301 free_comprehension((comprehension_ty)asdl_seq_GET(seq,
1302 i));
1303 asdl_seq_free(seq);
1304 break;
1305 case Yield_kind:
1306 if (o->v.Yield.value) {
1307 free_expr((expr_ty)o->v.Yield.value);
1308 }
1309 break;
1310 case Compare_kind:
1311 free_expr((expr_ty)o->v.Compare.left);
1312 seq = o->v.Compare.ops;
1313 n = asdl_seq_LEN(seq);
1314 for (i = 0; i < n; i++)
1315 free_cmpop((cmpop_ty)asdl_seq_GET(seq, i));
1316 asdl_seq_free(seq);
1317 free_seq_exprs(o->v.Compare.comparators);
1318 break;
1319 case Call_kind:
1320 free_expr((expr_ty)o->v.Call.func);
1321 free_seq_exprs(o->v.Call.args);
1322 seq = o->v.Call.keywords;
1323 n = asdl_seq_LEN(seq);
1324 for (i = 0; i < n; i++)
1325 free_keyword((keyword_ty)asdl_seq_GET(seq, i));
1326 asdl_seq_free(seq);
1327 if (o->v.Call.starargs) {
1328 free_expr((expr_ty)o->v.Call.starargs);
1329 }
1330 if (o->v.Call.kwargs) {
1331 free_expr((expr_ty)o->v.Call.kwargs);
1332 }
1333 break;
1334 case Repr_kind:
1335 free_expr((expr_ty)o->v.Repr.value);
1336 break;
1337 case Num_kind:
1338 Py_DECREF((object)o->v.Num.n);
1339 break;
1340 case Str_kind:
1341 Py_DECREF((string)o->v.Str.s);
1342 break;
1343 case Attribute_kind:
1344 free_expr((expr_ty)o->v.Attribute.value);
1345 Py_DECREF((identifier)o->v.Attribute.attr);
1346 free_expr_context((expr_context_ty)o->v.Attribute.ctx);
1347 break;
1348 case Subscript_kind:
1349 free_expr((expr_ty)o->v.Subscript.value);
1350 free_slice((slice_ty)o->v.Subscript.slice);
1351 free_expr_context((expr_context_ty)o->v.Subscript.ctx);
1352 break;
1353 case Name_kind:
1354 Py_DECREF((identifier)o->v.Name.id);
1355 free_expr_context((expr_context_ty)o->v.Name.ctx);
1356 break;
1357 case List_kind:
1358 free_seq_exprs(o->v.List.elts);
1359 free_expr_context((expr_context_ty)o->v.List.ctx);
1360 break;
1361 case Tuple_kind:
1362 free_seq_exprs(o->v.Tuple.elts);
1363 free_expr_context((expr_context_ty)o->v.Tuple.ctx);
1364 break;
1365 }
1366
1367 free(o);
1368}
1369
1370void
1371free_expr_context(expr_context_ty o)
1372{
1373 if (!o)
1374 return;
1375
1376}
1377
1378void
1379free_slice(slice_ty o)
1380{
1381 int i, n;
1382 asdl_seq *seq;
1383
1384 if (!o)
1385 return;
1386
1387 switch (o->kind) {
1388 case Ellipsis_kind:
1389 break;
1390 case Slice_kind:
1391 if (o->v.Slice.lower) {
1392 free_expr((expr_ty)o->v.Slice.lower);
1393 }
1394 if (o->v.Slice.upper) {
1395 free_expr((expr_ty)o->v.Slice.upper);
1396 }
1397 if (o->v.Slice.step) {
1398 free_expr((expr_ty)o->v.Slice.step);
1399 }
1400 break;
1401 case ExtSlice_kind:
1402 seq = o->v.ExtSlice.dims;
1403 n = asdl_seq_LEN(seq);
1404 for (i = 0; i < n; i++)
1405 free_slice((slice_ty)asdl_seq_GET(seq, i));
1406 asdl_seq_free(seq);
1407 break;
1408 case Index_kind:
1409 free_expr((expr_ty)o->v.Index.value);
1410 break;
1411 }
1412
1413 free(o);
1414}
1415
1416void
1417free_boolop(boolop_ty o)
1418{
1419 if (!o)
1420 return;
1421
1422}
1423
1424void
1425free_operator(operator_ty o)
1426{
1427 if (!o)
1428 return;
1429
1430}
1431
1432void
1433free_unaryop(unaryop_ty o)
1434{
1435 if (!o)
1436 return;
1437
1438}
1439
1440void
1441free_cmpop(cmpop_ty o)
1442{
1443 if (!o)
1444 return;
1445
1446}
1447
1448void
1449free_comprehension(comprehension_ty o)
1450{
1451 if (!o)
1452 return;
1453
1454 free_expr((expr_ty)o->target);
1455 free_expr((expr_ty)o->iter);
1456 free_seq_exprs(o->ifs);
1457
1458 free(o);
1459}
1460
1461void
1462free_excepthandler(excepthandler_ty o)
1463{
1464 if (!o)
1465 return;
1466
1467 if (o->type) {
1468 free_expr((expr_ty)o->type);
1469 }
1470 if (o->name) {
1471 free_expr((expr_ty)o->name);
1472 }
1473 free_seq_stmts(o->body);
1474
1475 free(o);
1476}
1477
1478void
1479free_arguments(arguments_ty o)
1480{
1481 if (!o)
1482 return;
1483
1484 free_seq_exprs(o->args);
1485 if (o->vararg) {
1486 Py_DECREF((identifier)o->vararg);
1487 }
1488 if (o->kwarg) {
1489 Py_DECREF((identifier)o->kwarg);
1490 }
1491 free_seq_exprs(o->defaults);
1492
1493 free(o);
1494}
1495
1496void
1497free_keyword(keyword_ty o)
1498{
1499 if (!o)
1500 return;
1501
1502 Py_DECREF((identifier)o->arg);
1503 free_expr((expr_ty)o->value);
1504
1505 free(o);
1506}
1507
1508void
1509free_alias(alias_ty o)
1510{
1511 if (!o)
1512 return;
1513
1514 Py_DECREF((identifier)o->name);
1515 if (o->asname) {
1516 Py_DECREF((identifier)o->asname);
1517 }
1518
1519 free(o);
1520}
1521
1522int
1523marshal_write_mod(PyObject **buf, int *off, mod_ty o)
1524{
1525 int i;
1526 switch (o->kind) {
1527 case Module_kind:
1528 marshal_write_int(buf, off, 1);
1529 marshal_write_int(buf, off, asdl_seq_LEN(o->v.Module.body));
1530 for (i = 0; i < asdl_seq_LEN(o->v.Module.body); i++) {
1531 void *elt = asdl_seq_GET(o->v.Module.body, i);
1532 marshal_write_stmt(buf, off, (stmt_ty)elt);
1533 }
1534 break;
1535 case Interactive_kind:
1536 marshal_write_int(buf, off, 2);
1537 marshal_write_int(buf, off,
1538 asdl_seq_LEN(o->v.Interactive.body));
1539 for (i = 0; i < asdl_seq_LEN(o->v.Interactive.body); i++) {
1540 void *elt = asdl_seq_GET(o->v.Interactive.body, i);
1541 marshal_write_stmt(buf, off, (stmt_ty)elt);
1542 }
1543 break;
1544 case Expression_kind:
1545 marshal_write_int(buf, off, 3);
1546 marshal_write_expr(buf, off, o->v.Expression.body);
1547 break;
1548 case Suite_kind:
1549 marshal_write_int(buf, off, 4);
1550 marshal_write_int(buf, off, asdl_seq_LEN(o->v.Suite.body));
1551 for (i = 0; i < asdl_seq_LEN(o->v.Suite.body); i++) {
1552 void *elt = asdl_seq_GET(o->v.Suite.body, i);
1553 marshal_write_stmt(buf, off, (stmt_ty)elt);
1554 }
1555 break;
1556 }
1557 return 1;
1558}
1559
1560int
1561marshal_write_stmt(PyObject **buf, int *off, stmt_ty o)
1562{
1563 int i;
1564 switch (o->kind) {
1565 case FunctionDef_kind:
1566 marshal_write_int(buf, off, 1);
1567 marshal_write_identifier(buf, off, o->v.FunctionDef.name);
1568 marshal_write_arguments(buf, off, o->v.FunctionDef.args);
1569 marshal_write_int(buf, off,
1570 asdl_seq_LEN(o->v.FunctionDef.body));
1571 for (i = 0; i < asdl_seq_LEN(o->v.FunctionDef.body); i++) {
1572 void *elt = asdl_seq_GET(o->v.FunctionDef.body, i);
1573 marshal_write_stmt(buf, off, (stmt_ty)elt);
1574 }
1575 marshal_write_int(buf, off,
1576 asdl_seq_LEN(o->v.FunctionDef.decorators));
1577 for (i = 0; i < asdl_seq_LEN(o->v.FunctionDef.decorators); i++)
1578 {
1579 void *elt = asdl_seq_GET(o->v.FunctionDef.decorators,
1580 i);
1581 marshal_write_expr(buf, off, (expr_ty)elt);
1582 }
1583 break;
1584 case ClassDef_kind:
1585 marshal_write_int(buf, off, 2);
1586 marshal_write_identifier(buf, off, o->v.ClassDef.name);
1587 marshal_write_int(buf, off, asdl_seq_LEN(o->v.ClassDef.bases));
1588 for (i = 0; i < asdl_seq_LEN(o->v.ClassDef.bases); i++) {
1589 void *elt = asdl_seq_GET(o->v.ClassDef.bases, i);
1590 marshal_write_expr(buf, off, (expr_ty)elt);
1591 }
1592 marshal_write_int(buf, off, asdl_seq_LEN(o->v.ClassDef.body));
1593 for (i = 0; i < asdl_seq_LEN(o->v.ClassDef.body); i++) {
1594 void *elt = asdl_seq_GET(o->v.ClassDef.body, i);
1595 marshal_write_stmt(buf, off, (stmt_ty)elt);
1596 }
1597 break;
1598 case Return_kind:
1599 marshal_write_int(buf, off, 3);
1600 if (o->v.Return.value) {
1601 marshal_write_int(buf, off, 1);
1602 marshal_write_expr(buf, off, o->v.Return.value);
1603 }
1604 else {
1605 marshal_write_int(buf, off, 0);
1606 }
1607 break;
1608 case Delete_kind:
1609 marshal_write_int(buf, off, 4);
1610 marshal_write_int(buf, off, asdl_seq_LEN(o->v.Delete.targets));
1611 for (i = 0; i < asdl_seq_LEN(o->v.Delete.targets); i++) {
1612 void *elt = asdl_seq_GET(o->v.Delete.targets, i);
1613 marshal_write_expr(buf, off, (expr_ty)elt);
1614 }
1615 break;
1616 case Assign_kind:
1617 marshal_write_int(buf, off, 5);
1618 marshal_write_int(buf, off, asdl_seq_LEN(o->v.Assign.targets));
1619 for (i = 0; i < asdl_seq_LEN(o->v.Assign.targets); i++) {
1620 void *elt = asdl_seq_GET(o->v.Assign.targets, i);
1621 marshal_write_expr(buf, off, (expr_ty)elt);
1622 }
1623 marshal_write_expr(buf, off, o->v.Assign.value);
1624 break;
1625 case AugAssign_kind:
1626 marshal_write_int(buf, off, 6);
1627 marshal_write_expr(buf, off, o->v.AugAssign.target);
1628 marshal_write_operator(buf, off, o->v.AugAssign.op);
1629 marshal_write_expr(buf, off, o->v.AugAssign.value);
1630 break;
1631 case Print_kind:
1632 marshal_write_int(buf, off, 7);
1633 if (o->v.Print.dest) {
1634 marshal_write_int(buf, off, 1);
1635 marshal_write_expr(buf, off, o->v.Print.dest);
1636 }
1637 else {
1638 marshal_write_int(buf, off, 0);
1639 }
1640 marshal_write_int(buf, off, asdl_seq_LEN(o->v.Print.values));
1641 for (i = 0; i < asdl_seq_LEN(o->v.Print.values); i++) {
1642 void *elt = asdl_seq_GET(o->v.Print.values, i);
1643 marshal_write_expr(buf, off, (expr_ty)elt);
1644 }
1645 marshal_write_bool(buf, off, o->v.Print.nl);
1646 break;
1647 case For_kind:
1648 marshal_write_int(buf, off, 8);
1649 marshal_write_expr(buf, off, o->v.For.target);
1650 marshal_write_expr(buf, off, o->v.For.iter);
1651 marshal_write_int(buf, off, asdl_seq_LEN(o->v.For.body));
1652 for (i = 0; i < asdl_seq_LEN(o->v.For.body); i++) {
1653 void *elt = asdl_seq_GET(o->v.For.body, i);
1654 marshal_write_stmt(buf, off, (stmt_ty)elt);
1655 }
1656 marshal_write_int(buf, off, asdl_seq_LEN(o->v.For.orelse));
1657 for (i = 0; i < asdl_seq_LEN(o->v.For.orelse); i++) {
1658 void *elt = asdl_seq_GET(o->v.For.orelse, i);
1659 marshal_write_stmt(buf, off, (stmt_ty)elt);
1660 }
1661 break;
1662 case While_kind:
1663 marshal_write_int(buf, off, 9);
1664 marshal_write_expr(buf, off, o->v.While.test);
1665 marshal_write_int(buf, off, asdl_seq_LEN(o->v.While.body));
1666 for (i = 0; i < asdl_seq_LEN(o->v.While.body); i++) {
1667 void *elt = asdl_seq_GET(o->v.While.body, i);
1668 marshal_write_stmt(buf, off, (stmt_ty)elt);
1669 }
1670 marshal_write_int(buf, off, asdl_seq_LEN(o->v.While.orelse));
1671 for (i = 0; i < asdl_seq_LEN(o->v.While.orelse); i++) {
1672 void *elt = asdl_seq_GET(o->v.While.orelse, i);
1673 marshal_write_stmt(buf, off, (stmt_ty)elt);
1674 }
1675 break;
1676 case If_kind:
1677 marshal_write_int(buf, off, 10);
1678 marshal_write_expr(buf, off, o->v.If.test);
1679 marshal_write_int(buf, off, asdl_seq_LEN(o->v.If.body));
1680 for (i = 0; i < asdl_seq_LEN(o->v.If.body); i++) {
1681 void *elt = asdl_seq_GET(o->v.If.body, i);
1682 marshal_write_stmt(buf, off, (stmt_ty)elt);
1683 }
1684 marshal_write_int(buf, off, asdl_seq_LEN(o->v.If.orelse));
1685 for (i = 0; i < asdl_seq_LEN(o->v.If.orelse); i++) {
1686 void *elt = asdl_seq_GET(o->v.If.orelse, i);
1687 marshal_write_stmt(buf, off, (stmt_ty)elt);
1688 }
1689 break;
1690 case Raise_kind:
1691 marshal_write_int(buf, off, 11);
1692 if (o->v.Raise.type) {
1693 marshal_write_int(buf, off, 1);
1694 marshal_write_expr(buf, off, o->v.Raise.type);
1695 }
1696 else {
1697 marshal_write_int(buf, off, 0);
1698 }
1699 if (o->v.Raise.inst) {
1700 marshal_write_int(buf, off, 1);
1701 marshal_write_expr(buf, off, o->v.Raise.inst);
1702 }
1703 else {
1704 marshal_write_int(buf, off, 0);
1705 }
1706 if (o->v.Raise.tback) {
1707 marshal_write_int(buf, off, 1);
1708 marshal_write_expr(buf, off, o->v.Raise.tback);
1709 }
1710 else {
1711 marshal_write_int(buf, off, 0);
1712 }
1713 break;
1714 case TryExcept_kind:
1715 marshal_write_int(buf, off, 12);
1716 marshal_write_int(buf, off, asdl_seq_LEN(o->v.TryExcept.body));
1717 for (i = 0; i < asdl_seq_LEN(o->v.TryExcept.body); i++) {
1718 void *elt = asdl_seq_GET(o->v.TryExcept.body, i);
1719 marshal_write_stmt(buf, off, (stmt_ty)elt);
1720 }
1721 marshal_write_int(buf, off,
1722 asdl_seq_LEN(o->v.TryExcept.handlers));
1723 for (i = 0; i < asdl_seq_LEN(o->v.TryExcept.handlers); i++) {
1724 void *elt = asdl_seq_GET(o->v.TryExcept.handlers, i);
1725 marshal_write_excepthandler(buf, off,
1726 (excepthandler_ty)elt);
1727 }
1728 marshal_write_int(buf, off,
1729 asdl_seq_LEN(o->v.TryExcept.orelse));
1730 for (i = 0; i < asdl_seq_LEN(o->v.TryExcept.orelse); i++) {
1731 void *elt = asdl_seq_GET(o->v.TryExcept.orelse, i);
1732 marshal_write_stmt(buf, off, (stmt_ty)elt);
1733 }
1734 break;
1735 case TryFinally_kind:
1736 marshal_write_int(buf, off, 13);
1737 marshal_write_int(buf, off, asdl_seq_LEN(o->v.TryFinally.body));
1738 for (i = 0; i < asdl_seq_LEN(o->v.TryFinally.body); i++) {
1739 void *elt = asdl_seq_GET(o->v.TryFinally.body, i);
1740 marshal_write_stmt(buf, off, (stmt_ty)elt);
1741 }
1742 marshal_write_int(buf, off,
1743 asdl_seq_LEN(o->v.TryFinally.finalbody));
1744 for (i = 0; i < asdl_seq_LEN(o->v.TryFinally.finalbody); i++) {
1745 void *elt = asdl_seq_GET(o->v.TryFinally.finalbody, i);
1746 marshal_write_stmt(buf, off, (stmt_ty)elt);
1747 }
1748 break;
1749 case Assert_kind:
1750 marshal_write_int(buf, off, 14);
1751 marshal_write_expr(buf, off, o->v.Assert.test);
1752 if (o->v.Assert.msg) {
1753 marshal_write_int(buf, off, 1);
1754 marshal_write_expr(buf, off, o->v.Assert.msg);
1755 }
1756 else {
1757 marshal_write_int(buf, off, 0);
1758 }
1759 break;
1760 case Import_kind:
1761 marshal_write_int(buf, off, 15);
1762 marshal_write_int(buf, off, asdl_seq_LEN(o->v.Import.names));
1763 for (i = 0; i < asdl_seq_LEN(o->v.Import.names); i++) {
1764 void *elt = asdl_seq_GET(o->v.Import.names, i);
1765 marshal_write_alias(buf, off, (alias_ty)elt);
1766 }
1767 break;
1768 case ImportFrom_kind:
1769 marshal_write_int(buf, off, 16);
1770 marshal_write_identifier(buf, off, o->v.ImportFrom.module);
1771 marshal_write_int(buf, off,
1772 asdl_seq_LEN(o->v.ImportFrom.names));
1773 for (i = 0; i < asdl_seq_LEN(o->v.ImportFrom.names); i++) {
1774 void *elt = asdl_seq_GET(o->v.ImportFrom.names, i);
1775 marshal_write_alias(buf, off, (alias_ty)elt);
1776 }
1777 break;
1778 case Exec_kind:
1779 marshal_write_int(buf, off, 17);
1780 marshal_write_expr(buf, off, o->v.Exec.body);
1781 if (o->v.Exec.globals) {
1782 marshal_write_int(buf, off, 1);
1783 marshal_write_expr(buf, off, o->v.Exec.globals);
1784 }
1785 else {
1786 marshal_write_int(buf, off, 0);
1787 }
1788 if (o->v.Exec.locals) {
1789 marshal_write_int(buf, off, 1);
1790 marshal_write_expr(buf, off, o->v.Exec.locals);
1791 }
1792 else {
1793 marshal_write_int(buf, off, 0);
1794 }
1795 break;
1796 case Global_kind:
1797 marshal_write_int(buf, off, 18);
1798 marshal_write_int(buf, off, asdl_seq_LEN(o->v.Global.names));
1799 for (i = 0; i < asdl_seq_LEN(o->v.Global.names); i++) {
1800 void *elt = asdl_seq_GET(o->v.Global.names, i);
1801 marshal_write_identifier(buf, off, (identifier)elt);
1802 }
1803 break;
1804 case Expr_kind:
1805 marshal_write_int(buf, off, 19);
1806 marshal_write_expr(buf, off, o->v.Expr.value);
1807 break;
1808 case Pass_kind:
1809 marshal_write_int(buf, off, 20);
1810 break;
1811 case Break_kind:
1812 marshal_write_int(buf, off, 21);
1813 break;
1814 case Continue_kind:
1815 marshal_write_int(buf, off, 22);
1816 break;
1817 }
1818 return 1;
1819}
1820
1821int
1822marshal_write_expr(PyObject **buf, int *off, expr_ty o)
1823{
1824 int i;
1825 switch (o->kind) {
1826 case BoolOp_kind:
1827 marshal_write_int(buf, off, 1);
1828 marshal_write_boolop(buf, off, o->v.BoolOp.op);
1829 marshal_write_int(buf, off, asdl_seq_LEN(o->v.BoolOp.values));
1830 for (i = 0; i < asdl_seq_LEN(o->v.BoolOp.values); i++) {
1831 void *elt = asdl_seq_GET(o->v.BoolOp.values, i);
1832 marshal_write_expr(buf, off, (expr_ty)elt);
1833 }
1834 break;
1835 case BinOp_kind:
1836 marshal_write_int(buf, off, 2);
1837 marshal_write_expr(buf, off, o->v.BinOp.left);
1838 marshal_write_operator(buf, off, o->v.BinOp.op);
1839 marshal_write_expr(buf, off, o->v.BinOp.right);
1840 break;
1841 case UnaryOp_kind:
1842 marshal_write_int(buf, off, 3);
1843 marshal_write_unaryop(buf, off, o->v.UnaryOp.op);
1844 marshal_write_expr(buf, off, o->v.UnaryOp.operand);
1845 break;
1846 case Lambda_kind:
1847 marshal_write_int(buf, off, 4);
1848 marshal_write_arguments(buf, off, o->v.Lambda.args);
1849 marshal_write_expr(buf, off, o->v.Lambda.body);
1850 break;
1851 case Dict_kind:
1852 marshal_write_int(buf, off, 5);
1853 marshal_write_int(buf, off, asdl_seq_LEN(o->v.Dict.keys));
1854 for (i = 0; i < asdl_seq_LEN(o->v.Dict.keys); i++) {
1855 void *elt = asdl_seq_GET(o->v.Dict.keys, i);
1856 marshal_write_expr(buf, off, (expr_ty)elt);
1857 }
1858 marshal_write_int(buf, off, asdl_seq_LEN(o->v.Dict.values));
1859 for (i = 0; i < asdl_seq_LEN(o->v.Dict.values); i++) {
1860 void *elt = asdl_seq_GET(o->v.Dict.values, i);
1861 marshal_write_expr(buf, off, (expr_ty)elt);
1862 }
1863 break;
1864 case ListComp_kind:
1865 marshal_write_int(buf, off, 6);
1866 marshal_write_expr(buf, off, o->v.ListComp.elt);
1867 marshal_write_int(buf, off,
1868 asdl_seq_LEN(o->v.ListComp.generators));
1869 for (i = 0; i < asdl_seq_LEN(o->v.ListComp.generators); i++) {
1870 void *elt = asdl_seq_GET(o->v.ListComp.generators, i);
1871 marshal_write_comprehension(buf, off,
1872 (comprehension_ty)elt);
1873 }
1874 break;
1875 case GeneratorExp_kind:
1876 marshal_write_int(buf, off, 7);
1877 marshal_write_expr(buf, off, o->v.GeneratorExp.elt);
1878 marshal_write_int(buf, off,
1879 asdl_seq_LEN(o->v.GeneratorExp.generators));
1880 for (i = 0; i < asdl_seq_LEN(o->v.GeneratorExp.generators);
1881 i++) {
1882 void *elt = asdl_seq_GET(o->v.GeneratorExp.generators,
1883 i);
1884 marshal_write_comprehension(buf, off,
1885 (comprehension_ty)elt);
1886 }
1887 break;
1888 case Yield_kind:
1889 marshal_write_int(buf, off, 8);
1890 if (o->v.Yield.value) {
1891 marshal_write_int(buf, off, 1);
1892 marshal_write_expr(buf, off, o->v.Yield.value);
1893 }
1894 else {
1895 marshal_write_int(buf, off, 0);
1896 }
1897 break;
1898 case Compare_kind:
1899 marshal_write_int(buf, off, 9);
1900 marshal_write_expr(buf, off, o->v.Compare.left);
1901 marshal_write_int(buf, off, asdl_seq_LEN(o->v.Compare.ops));
1902 for (i = 0; i < asdl_seq_LEN(o->v.Compare.ops); i++) {
1903 void *elt = asdl_seq_GET(o->v.Compare.ops, i);
1904 marshal_write_cmpop(buf, off, (cmpop_ty)elt);
1905 }
1906 marshal_write_int(buf, off,
1907 asdl_seq_LEN(o->v.Compare.comparators));
1908 for (i = 0; i < asdl_seq_LEN(o->v.Compare.comparators); i++) {
1909 void *elt = asdl_seq_GET(o->v.Compare.comparators, i);
1910 marshal_write_expr(buf, off, (expr_ty)elt);
1911 }
1912 break;
1913 case Call_kind:
1914 marshal_write_int(buf, off, 10);
1915 marshal_write_expr(buf, off, o->v.Call.func);
1916 marshal_write_int(buf, off, asdl_seq_LEN(o->v.Call.args));
1917 for (i = 0; i < asdl_seq_LEN(o->v.Call.args); i++) {
1918 void *elt = asdl_seq_GET(o->v.Call.args, i);
1919 marshal_write_expr(buf, off, (expr_ty)elt);
1920 }
1921 marshal_write_int(buf, off, asdl_seq_LEN(o->v.Call.keywords));
1922 for (i = 0; i < asdl_seq_LEN(o->v.Call.keywords); i++) {
1923 void *elt = asdl_seq_GET(o->v.Call.keywords, i);
1924 marshal_write_keyword(buf, off, (keyword_ty)elt);
1925 }
1926 if (o->v.Call.starargs) {
1927 marshal_write_int(buf, off, 1);
1928 marshal_write_expr(buf, off, o->v.Call.starargs);
1929 }
1930 else {
1931 marshal_write_int(buf, off, 0);
1932 }
1933 if (o->v.Call.kwargs) {
1934 marshal_write_int(buf, off, 1);
1935 marshal_write_expr(buf, off, o->v.Call.kwargs);
1936 }
1937 else {
1938 marshal_write_int(buf, off, 0);
1939 }
1940 break;
1941 case Repr_kind:
1942 marshal_write_int(buf, off, 11);
1943 marshal_write_expr(buf, off, o->v.Repr.value);
1944 break;
1945 case Num_kind:
1946 marshal_write_int(buf, off, 12);
1947 marshal_write_object(buf, off, o->v.Num.n);
1948 break;
1949 case Str_kind:
1950 marshal_write_int(buf, off, 13);
1951 marshal_write_string(buf, off, o->v.Str.s);
1952 break;
1953 case Attribute_kind:
1954 marshal_write_int(buf, off, 14);
1955 marshal_write_expr(buf, off, o->v.Attribute.value);
1956 marshal_write_identifier(buf, off, o->v.Attribute.attr);
1957 marshal_write_expr_context(buf, off, o->v.Attribute.ctx);
1958 break;
1959 case Subscript_kind:
1960 marshal_write_int(buf, off, 15);
1961 marshal_write_expr(buf, off, o->v.Subscript.value);
1962 marshal_write_slice(buf, off, o->v.Subscript.slice);
1963 marshal_write_expr_context(buf, off, o->v.Subscript.ctx);
1964 break;
1965 case Name_kind:
1966 marshal_write_int(buf, off, 16);
1967 marshal_write_identifier(buf, off, o->v.Name.id);
1968 marshal_write_expr_context(buf, off, o->v.Name.ctx);
1969 break;
1970 case List_kind:
1971 marshal_write_int(buf, off, 17);
1972 marshal_write_int(buf, off, asdl_seq_LEN(o->v.List.elts));
1973 for (i = 0; i < asdl_seq_LEN(o->v.List.elts); i++) {
1974 void *elt = asdl_seq_GET(o->v.List.elts, i);
1975 marshal_write_expr(buf, off, (expr_ty)elt);
1976 }
1977 marshal_write_expr_context(buf, off, o->v.List.ctx);
1978 break;
1979 case Tuple_kind:
1980 marshal_write_int(buf, off, 18);
1981 marshal_write_int(buf, off, asdl_seq_LEN(o->v.Tuple.elts));
1982 for (i = 0; i < asdl_seq_LEN(o->v.Tuple.elts); i++) {
1983 void *elt = asdl_seq_GET(o->v.Tuple.elts, i);
1984 marshal_write_expr(buf, off, (expr_ty)elt);
1985 }
1986 marshal_write_expr_context(buf, off, o->v.Tuple.ctx);
1987 break;
1988 }
1989 return 1;
1990}
1991
1992int
1993marshal_write_expr_context(PyObject **buf, int *off, expr_context_ty o)
1994{
1995 int i;
1996 switch (o) {
1997 case Load:
1998 marshal_write_int(buf, off, 1);
1999 break;
2000 case Store:
2001 marshal_write_int(buf, off, 2);
2002 break;
2003 case Del:
2004 marshal_write_int(buf, off, 3);
2005 break;
2006 case AugLoad:
2007 marshal_write_int(buf, off, 4);
2008 break;
2009 case AugStore:
2010 marshal_write_int(buf, off, 5);
2011 break;
2012 case Param:
2013 marshal_write_int(buf, off, 6);
2014 break;
2015 }
2016 return 1;
2017}
2018
2019int
2020marshal_write_slice(PyObject **buf, int *off, slice_ty o)
2021{
2022 int i;
2023 switch (o->kind) {
2024 case Ellipsis_kind:
2025 marshal_write_int(buf, off, 1);
2026 break;
2027 case Slice_kind:
2028 marshal_write_int(buf, off, 2);
2029 if (o->v.Slice.lower) {
2030 marshal_write_int(buf, off, 1);
2031 marshal_write_expr(buf, off, o->v.Slice.lower);
2032 }
2033 else {
2034 marshal_write_int(buf, off, 0);
2035 }
2036 if (o->v.Slice.upper) {
2037 marshal_write_int(buf, off, 1);
2038 marshal_write_expr(buf, off, o->v.Slice.upper);
2039 }
2040 else {
2041 marshal_write_int(buf, off, 0);
2042 }
2043 if (o->v.Slice.step) {
2044 marshal_write_int(buf, off, 1);
2045 marshal_write_expr(buf, off, o->v.Slice.step);
2046 }
2047 else {
2048 marshal_write_int(buf, off, 0);
2049 }
2050 break;
2051 case ExtSlice_kind:
2052 marshal_write_int(buf, off, 3);
2053 marshal_write_int(buf, off, asdl_seq_LEN(o->v.ExtSlice.dims));
2054 for (i = 0; i < asdl_seq_LEN(o->v.ExtSlice.dims); i++) {
2055 void *elt = asdl_seq_GET(o->v.ExtSlice.dims, i);
2056 marshal_write_slice(buf, off, (slice_ty)elt);
2057 }
2058 break;
2059 case Index_kind:
2060 marshal_write_int(buf, off, 4);
2061 marshal_write_expr(buf, off, o->v.Index.value);
2062 break;
2063 }
2064 return 1;
2065}
2066
2067int
2068marshal_write_boolop(PyObject **buf, int *off, boolop_ty o)
2069{
2070 int i;
2071 switch (o) {
2072 case And:
2073 marshal_write_int(buf, off, 1);
2074 break;
2075 case Or:
2076 marshal_write_int(buf, off, 2);
2077 break;
2078 }
2079 return 1;
2080}
2081
2082int
2083marshal_write_operator(PyObject **buf, int *off, operator_ty o)
2084{
2085 int i;
2086 switch (o) {
2087 case Add:
2088 marshal_write_int(buf, off, 1);
2089 break;
2090 case Sub:
2091 marshal_write_int(buf, off, 2);
2092 break;
2093 case Mult:
2094 marshal_write_int(buf, off, 3);
2095 break;
2096 case Div:
2097 marshal_write_int(buf, off, 4);
2098 break;
2099 case Mod:
2100 marshal_write_int(buf, off, 5);
2101 break;
2102 case Pow:
2103 marshal_write_int(buf, off, 6);
2104 break;
2105 case LShift:
2106 marshal_write_int(buf, off, 7);
2107 break;
2108 case RShift:
2109 marshal_write_int(buf, off, 8);
2110 break;
2111 case BitOr:
2112 marshal_write_int(buf, off, 9);
2113 break;
2114 case BitXor:
2115 marshal_write_int(buf, off, 10);
2116 break;
2117 case BitAnd:
2118 marshal_write_int(buf, off, 11);
2119 break;
2120 case FloorDiv:
2121 marshal_write_int(buf, off, 12);
2122 break;
2123 }
2124 return 1;
2125}
2126
2127int
2128marshal_write_unaryop(PyObject **buf, int *off, unaryop_ty o)
2129{
2130 int i;
2131 switch (o) {
2132 case Invert:
2133 marshal_write_int(buf, off, 1);
2134 break;
2135 case Not:
2136 marshal_write_int(buf, off, 2);
2137 break;
2138 case UAdd:
2139 marshal_write_int(buf, off, 3);
2140 break;
2141 case USub:
2142 marshal_write_int(buf, off, 4);
2143 break;
2144 }
2145 return 1;
2146}
2147
2148int
2149marshal_write_cmpop(PyObject **buf, int *off, cmpop_ty o)
2150{
2151 int i;
2152 switch (o) {
2153 case Eq:
2154 marshal_write_int(buf, off, 1);
2155 break;
2156 case NotEq:
2157 marshal_write_int(buf, off, 2);
2158 break;
2159 case Lt:
2160 marshal_write_int(buf, off, 3);
2161 break;
2162 case LtE:
2163 marshal_write_int(buf, off, 4);
2164 break;
2165 case Gt:
2166 marshal_write_int(buf, off, 5);
2167 break;
2168 case GtE:
2169 marshal_write_int(buf, off, 6);
2170 break;
2171 case Is:
2172 marshal_write_int(buf, off, 7);
2173 break;
2174 case IsNot:
2175 marshal_write_int(buf, off, 8);
2176 break;
2177 case In:
2178 marshal_write_int(buf, off, 9);
2179 break;
2180 case NotIn:
2181 marshal_write_int(buf, off, 10);
2182 break;
2183 }
2184 return 1;
2185}
2186
2187int
2188marshal_write_comprehension(PyObject **buf, int *off, comprehension_ty o)
2189{
2190 int i;
2191 marshal_write_expr(buf, off, o->target);
2192 marshal_write_expr(buf, off, o->iter);
2193 marshal_write_int(buf, off, asdl_seq_LEN(o->ifs));
2194 for (i = 0; i < asdl_seq_LEN(o->ifs); i++) {
2195 void *elt = asdl_seq_GET(o->ifs, i);
2196 marshal_write_expr(buf, off, (expr_ty)elt);
2197 }
2198 return 1;
2199}
2200
2201int
2202marshal_write_excepthandler(PyObject **buf, int *off, excepthandler_ty o)
2203{
2204 int i;
2205 if (o->type) {
2206 marshal_write_int(buf, off, 1);
2207 marshal_write_expr(buf, off, o->type);
2208 }
2209 else {
2210 marshal_write_int(buf, off, 0);
2211 }
2212 if (o->name) {
2213 marshal_write_int(buf, off, 1);
2214 marshal_write_expr(buf, off, o->name);
2215 }
2216 else {
2217 marshal_write_int(buf, off, 0);
2218 }
2219 marshal_write_int(buf, off, asdl_seq_LEN(o->body));
2220 for (i = 0; i < asdl_seq_LEN(o->body); i++) {
2221 void *elt = asdl_seq_GET(o->body, i);
2222 marshal_write_stmt(buf, off, (stmt_ty)elt);
2223 }
2224 return 1;
2225}
2226
2227int
2228marshal_write_arguments(PyObject **buf, int *off, arguments_ty o)
2229{
2230 int i;
2231 marshal_write_int(buf, off, asdl_seq_LEN(o->args));
2232 for (i = 0; i < asdl_seq_LEN(o->args); i++) {
2233 void *elt = asdl_seq_GET(o->args, i);
2234 marshal_write_expr(buf, off, (expr_ty)elt);
2235 }
2236 if (o->vararg) {
2237 marshal_write_int(buf, off, 1);
2238 marshal_write_identifier(buf, off, o->vararg);
2239 }
2240 else {
2241 marshal_write_int(buf, off, 0);
2242 }
2243 if (o->kwarg) {
2244 marshal_write_int(buf, off, 1);
2245 marshal_write_identifier(buf, off, o->kwarg);
2246 }
2247 else {
2248 marshal_write_int(buf, off, 0);
2249 }
2250 marshal_write_int(buf, off, asdl_seq_LEN(o->defaults));
2251 for (i = 0; i < asdl_seq_LEN(o->defaults); i++) {
2252 void *elt = asdl_seq_GET(o->defaults, i);
2253 marshal_write_expr(buf, off, (expr_ty)elt);
2254 }
2255 return 1;
2256}
2257
2258int
2259marshal_write_keyword(PyObject **buf, int *off, keyword_ty o)
2260{
2261 int i;
2262 marshal_write_identifier(buf, off, o->arg);
2263 marshal_write_expr(buf, off, o->value);
2264 return 1;
2265}
2266
2267int
2268marshal_write_alias(PyObject **buf, int *off, alias_ty o)
2269{
2270 int i;
2271 marshal_write_identifier(buf, off, o->name);
2272 if (o->asname) {
2273 marshal_write_int(buf, off, 1);
2274 marshal_write_identifier(buf, off, o->asname);
2275 }
2276 else {
2277 marshal_write_int(buf, off, 0);
2278 }
2279 return 1;
2280}
2281