home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2009 December / maximum-cd-2009-12.iso / DiscContents / YoFrankie.msi / CS_runtime.cab / Python_ast.h.6B976ADF_8AE8_434E_B282_A06C7F624D2F < prev    next >
Encoding:
Text File  |  2007-01-19  |  19.7 KB  |  502 lines
  1. /* File automatically generated by Parser/asdl_c.py */
  2.  
  3. #include "asdl.h"
  4.  
  5. typedef struct _mod *mod_ty;
  6.  
  7. typedef struct _stmt *stmt_ty;
  8.  
  9. typedef struct _expr *expr_ty;
  10.  
  11. typedef enum _expr_context { Load=1, Store=2, Del=3, AugLoad=4, AugStore=5,
  12.                              Param=6 } expr_context_ty;
  13.  
  14. typedef struct _slice *slice_ty;
  15.  
  16. typedef enum _boolop { And=1, Or=2 } boolop_ty;
  17.  
  18. typedef enum _operator { Add=1, Sub=2, Mult=3, Div=4, Mod=5, Pow=6, LShift=7,
  19.                          RShift=8, BitOr=9, BitXor=10, BitAnd=11, FloorDiv=12 }
  20.                          operator_ty;
  21.  
  22. typedef enum _unaryop { Invert=1, Not=2, UAdd=3, USub=4 } unaryop_ty;
  23.  
  24. typedef enum _cmpop { Eq=1, NotEq=2, Lt=3, LtE=4, Gt=5, GtE=6, Is=7, IsNot=8,
  25.                       In=9, NotIn=10 } cmpop_ty;
  26.  
  27. typedef struct _comprehension *comprehension_ty;
  28.  
  29. typedef struct _excepthandler *excepthandler_ty;
  30.  
  31. typedef struct _arguments *arguments_ty;
  32.  
  33. typedef struct _keyword *keyword_ty;
  34.  
  35. typedef struct _alias *alias_ty;
  36.  
  37.  
  38. enum _mod_kind {Module_kind=1, Interactive_kind=2, Expression_kind=3,
  39.                  Suite_kind=4};
  40. struct _mod {
  41.         enum _mod_kind kind;
  42.         union {
  43.                 struct {
  44.                         asdl_seq *body;
  45.                 } Module;
  46.                 
  47.                 struct {
  48.                         asdl_seq *body;
  49.                 } Interactive;
  50.                 
  51.                 struct {
  52.                         expr_ty body;
  53.                 } Expression;
  54.                 
  55.                 struct {
  56.                         asdl_seq *body;
  57.                 } Suite;
  58.                 
  59.         } v;
  60. };
  61.  
  62. enum _stmt_kind {FunctionDef_kind=1, ClassDef_kind=2, Return_kind=3,
  63.                   Delete_kind=4, Assign_kind=5, AugAssign_kind=6, Print_kind=7,
  64.                   For_kind=8, While_kind=9, If_kind=10, With_kind=11,
  65.                   Raise_kind=12, TryExcept_kind=13, TryFinally_kind=14,
  66.                   Assert_kind=15, Import_kind=16, ImportFrom_kind=17,
  67.                   Exec_kind=18, Global_kind=19, Expr_kind=20, Pass_kind=21,
  68.                   Break_kind=22, Continue_kind=23};
  69. struct _stmt {
  70.         enum _stmt_kind kind;
  71.         union {
  72.                 struct {
  73.                         identifier name;
  74.                         arguments_ty args;
  75.                         asdl_seq *body;
  76.                         asdl_seq *decorators;
  77.                 } FunctionDef;
  78.                 
  79.                 struct {
  80.                         identifier name;
  81.                         asdl_seq *bases;
  82.                         asdl_seq *body;
  83.                 } ClassDef;
  84.                 
  85.                 struct {
  86.                         expr_ty value;
  87.                 } Return;
  88.                 
  89.                 struct {
  90.                         asdl_seq *targets;
  91.                 } Delete;
  92.                 
  93.                 struct {
  94.                         asdl_seq *targets;
  95.                         expr_ty value;
  96.                 } Assign;
  97.                 
  98.                 struct {
  99.                         expr_ty target;
  100.                         operator_ty op;
  101.                         expr_ty value;
  102.                 } AugAssign;
  103.                 
  104.                 struct {
  105.                         expr_ty dest;
  106.                         asdl_seq *values;
  107.                         bool nl;
  108.                 } Print;
  109.                 
  110.                 struct {
  111.                         expr_ty target;
  112.                         expr_ty iter;
  113.                         asdl_seq *body;
  114.                         asdl_seq *orelse;
  115.                 } For;
  116.                 
  117.                 struct {
  118.                         expr_ty test;
  119.                         asdl_seq *body;
  120.                         asdl_seq *orelse;
  121.                 } While;
  122.                 
  123.                 struct {
  124.                         expr_ty test;
  125.                         asdl_seq *body;
  126.                         asdl_seq *orelse;
  127.                 } If;
  128.                 
  129.                 struct {
  130.                         expr_ty context_expr;
  131.                         expr_ty optional_vars;
  132.                         asdl_seq *body;
  133.                 } With;
  134.                 
  135.                 struct {
  136.                         expr_ty type;
  137.                         expr_ty inst;
  138.                         expr_ty tback;
  139.                 } Raise;
  140.                 
  141.                 struct {
  142.                         asdl_seq *body;
  143.                         asdl_seq *handlers;
  144.                         asdl_seq *orelse;
  145.                 } TryExcept;
  146.                 
  147.                 struct {
  148.                         asdl_seq *body;
  149.                         asdl_seq *finalbody;
  150.                 } TryFinally;
  151.                 
  152.                 struct {
  153.                         expr_ty test;
  154.                         expr_ty msg;
  155.                 } Assert;
  156.                 
  157.                 struct {
  158.                         asdl_seq *names;
  159.                 } Import;
  160.                 
  161.                 struct {
  162.                         identifier module;
  163.                         asdl_seq *names;
  164.                         int level;
  165.                 } ImportFrom;
  166.                 
  167.                 struct {
  168.                         expr_ty body;
  169.                         expr_ty globals;
  170.                         expr_ty locals;
  171.                 } Exec;
  172.                 
  173.                 struct {
  174.                         asdl_seq *names;
  175.                 } Global;
  176.                 
  177.                 struct {
  178.                         expr_ty value;
  179.                 } Expr;
  180.                 
  181.         } v;
  182.         int lineno;
  183.         int col_offset;
  184. };
  185.  
  186. enum _expr_kind {BoolOp_kind=1, BinOp_kind=2, UnaryOp_kind=3, Lambda_kind=4,
  187.                   IfExp_kind=5, Dict_kind=6, ListComp_kind=7,
  188.                   GeneratorExp_kind=8, Yield_kind=9, Compare_kind=10,
  189.                   Call_kind=11, Repr_kind=12, Num_kind=13, Str_kind=14,
  190.                   Attribute_kind=15, Subscript_kind=16, Name_kind=17,
  191.                   List_kind=18, Tuple_kind=19};
  192. struct _expr {
  193.         enum _expr_kind kind;
  194.         union {
  195.                 struct {
  196.                         boolop_ty op;
  197.                         asdl_seq *values;
  198.                 } BoolOp;
  199.                 
  200.                 struct {
  201.                         expr_ty left;
  202.                         operator_ty op;
  203.                         expr_ty right;
  204.                 } BinOp;
  205.                 
  206.                 struct {
  207.                         unaryop_ty op;
  208.                         expr_ty operand;
  209.                 } UnaryOp;
  210.                 
  211.                 struct {
  212.                         arguments_ty args;
  213.                         expr_ty body;
  214.                 } Lambda;
  215.                 
  216.                 struct {
  217.                         expr_ty test;
  218.                         expr_ty body;
  219.                         expr_ty orelse;
  220.                 } IfExp;
  221.                 
  222.                 struct {
  223.                         asdl_seq *keys;
  224.                         asdl_seq *values;
  225.                 } Dict;
  226.                 
  227.                 struct {
  228.                         expr_ty elt;
  229.                         asdl_seq *generators;
  230.                 } ListComp;
  231.                 
  232.                 struct {
  233.                         expr_ty elt;
  234.                         asdl_seq *generators;
  235.                 } GeneratorExp;
  236.                 
  237.                 struct {
  238.                         expr_ty value;
  239.                 } Yield;
  240.                 
  241.                 struct {
  242.                         expr_ty left;
  243.                         asdl_int_seq *ops;
  244.                         asdl_seq *comparators;
  245.                 } Compare;
  246.                 
  247.                 struct {
  248.                         expr_ty func;
  249.                         asdl_seq *args;
  250.                         asdl_seq *keywords;
  251.                         expr_ty starargs;
  252.                         expr_ty kwargs;
  253.                 } Call;
  254.                 
  255.                 struct {
  256.                         expr_ty value;
  257.                 } Repr;
  258.                 
  259.                 struct {
  260.                         object n;
  261.                 } Num;
  262.                 
  263.                 struct {
  264.                         string s;
  265.                 } Str;
  266.                 
  267.                 struct {
  268.                         expr_ty value;
  269.                         identifier attr;
  270.                         expr_context_ty ctx;
  271.                 } Attribute;
  272.                 
  273.                 struct {
  274.                         expr_ty value;
  275.                         slice_ty slice;
  276.                         expr_context_ty ctx;
  277.                 } Subscript;
  278.                 
  279.                 struct {
  280.                         identifier id;
  281.                         expr_context_ty ctx;
  282.                 } Name;
  283.                 
  284.                 struct {
  285.                         asdl_seq *elts;
  286.                         expr_context_ty ctx;
  287.                 } List;
  288.                 
  289.                 struct {
  290.                         asdl_seq *elts;
  291.                         expr_context_ty ctx;
  292.                 } Tuple;
  293.                 
  294.         } v;
  295.         int lineno;
  296.         int col_offset;
  297. };
  298.  
  299. enum _slice_kind {Ellipsis_kind=1, Slice_kind=2, ExtSlice_kind=3, Index_kind=4};
  300. struct _slice {
  301.         enum _slice_kind kind;
  302.         union {
  303.                 struct {
  304.                         expr_ty lower;
  305.                         expr_ty upper;
  306.                         expr_ty step;
  307.                 } Slice;
  308.                 
  309.                 struct {
  310.                         asdl_seq *dims;
  311.                 } ExtSlice;
  312.                 
  313.                 struct {
  314.                         expr_ty value;
  315.                 } Index;
  316.                 
  317.         } v;
  318. };
  319.  
  320. struct _comprehension {
  321.         expr_ty target;
  322.         expr_ty iter;
  323.         asdl_seq *ifs;
  324. };
  325.  
  326. struct _excepthandler {
  327.         expr_ty type;
  328.         expr_ty name;
  329.         asdl_seq *body;
  330.         int lineno;
  331.         int col_offset;
  332. };
  333.  
  334. struct _arguments {
  335.         asdl_seq *args;
  336.         identifier vararg;
  337.         identifier kwarg;
  338.         asdl_seq *defaults;
  339. };
  340.  
  341. struct _keyword {
  342.         identifier arg;
  343.         expr_ty value;
  344. };
  345.  
  346. struct _alias {
  347.         identifier name;
  348.         identifier asname;
  349. };
  350.  
  351.  
  352. #define Module(a0, a1) _Py_Module(a0, a1)
  353. mod_ty _Py_Module(asdl_seq * body, PyArena *arena);
  354. #define Interactive(a0, a1) _Py_Interactive(a0, a1)
  355. mod_ty _Py_Interactive(asdl_seq * body, PyArena *arena);
  356. #define Expression(a0, a1) _Py_Expression(a0, a1)
  357. mod_ty _Py_Expression(expr_ty body, PyArena *arena);
  358. #define Suite(a0, a1) _Py_Suite(a0, a1)
  359. mod_ty _Py_Suite(asdl_seq * body, PyArena *arena);
  360. #define FunctionDef(a0, a1, a2, a3, a4, a5, a6) _Py_FunctionDef(a0, a1, a2, a3, a4, a5, a6)
  361. stmt_ty _Py_FunctionDef(identifier name, arguments_ty args, asdl_seq * body,
  362.                         asdl_seq * decorators, int lineno, int col_offset,
  363.                         PyArena *arena);
  364. #define ClassDef(a0, a1, a2, a3, a4, a5) _Py_ClassDef(a0, a1, a2, a3, a4, a5)
  365. stmt_ty _Py_ClassDef(identifier name, asdl_seq * bases, asdl_seq * body, int
  366.                      lineno, int col_offset, PyArena *arena);
  367. #define Return(a0, a1, a2, a3) _Py_Return(a0, a1, a2, a3)
  368. stmt_ty _Py_Return(expr_ty value, int lineno, int col_offset, PyArena *arena);
  369. #define Delete(a0, a1, a2, a3) _Py_Delete(a0, a1, a2, a3)
  370. stmt_ty _Py_Delete(asdl_seq * targets, int lineno, int col_offset, PyArena
  371.                    *arena);
  372. #define Assign(a0, a1, a2, a3, a4) _Py_Assign(a0, a1, a2, a3, a4)
  373. stmt_ty _Py_Assign(asdl_seq * targets, expr_ty value, int lineno, int
  374.                    col_offset, PyArena *arena);
  375. #define AugAssign(a0, a1, a2, a3, a4, a5) _Py_AugAssign(a0, a1, a2, a3, a4, a5)
  376. stmt_ty _Py_AugAssign(expr_ty target, operator_ty op, expr_ty value, int
  377.                       lineno, int col_offset, PyArena *arena);
  378. #define Print(a0, a1, a2, a3, a4, a5) _Py_Print(a0, a1, a2, a3, a4, a5)
  379. stmt_ty _Py_Print(expr_ty dest, asdl_seq * values, bool nl, int lineno, int
  380.                   col_offset, PyArena *arena);
  381. #define For(a0, a1, a2, a3, a4, a5, a6) _Py_For(a0, a1, a2, a3, a4, a5, a6)
  382. stmt_ty _Py_For(expr_ty target, expr_ty iter, asdl_seq * body, asdl_seq *
  383.                 orelse, int lineno, int col_offset, PyArena *arena);
  384. #define While(a0, a1, a2, a3, a4, a5) _Py_While(a0, a1, a2, a3, a4, a5)
  385. stmt_ty _Py_While(expr_ty test, asdl_seq * body, asdl_seq * orelse, int lineno,
  386.                   int col_offset, PyArena *arena);
  387. #define If(a0, a1, a2, a3, a4, a5) _Py_If(a0, a1, a2, a3, a4, a5)
  388. stmt_ty _Py_If(expr_ty test, asdl_seq * body, asdl_seq * orelse, int lineno,
  389.                int col_offset, PyArena *arena);
  390. #define With(a0, a1, a2, a3, a4, a5) _Py_With(a0, a1, a2, a3, a4, a5)
  391. stmt_ty _Py_With(expr_ty context_expr, expr_ty optional_vars, asdl_seq * body,
  392.                  int lineno, int col_offset, PyArena *arena);
  393. #define Raise(a0, a1, a2, a3, a4, a5) _Py_Raise(a0, a1, a2, a3, a4, a5)
  394. stmt_ty _Py_Raise(expr_ty type, expr_ty inst, expr_ty tback, int lineno, int
  395.                   col_offset, PyArena *arena);
  396. #define TryExcept(a0, a1, a2, a3, a4, a5) _Py_TryExcept(a0, a1, a2, a3, a4, a5)
  397. stmt_ty _Py_TryExcept(asdl_seq * body, asdl_seq * handlers, asdl_seq * orelse,
  398.                       int lineno, int col_offset, PyArena *arena);
  399. #define TryFinally(a0, a1, a2, a3, a4) _Py_TryFinally(a0, a1, a2, a3, a4)
  400. stmt_ty _Py_TryFinally(asdl_seq * body, asdl_seq * finalbody, int lineno, int
  401.                        col_offset, PyArena *arena);
  402. #define Assert(a0, a1, a2, a3, a4) _Py_Assert(a0, a1, a2, a3, a4)
  403. stmt_ty _Py_Assert(expr_ty test, expr_ty msg, int lineno, int col_offset,
  404.                    PyArena *arena);
  405. #define Import(a0, a1, a2, a3) _Py_Import(a0, a1, a2, a3)
  406. stmt_ty _Py_Import(asdl_seq * names, int lineno, int col_offset, PyArena
  407.                    *arena);
  408. #define ImportFrom(a0, a1, a2, a3, a4, a5) _Py_ImportFrom(a0, a1, a2, a3, a4, a5)
  409. stmt_ty _Py_ImportFrom(identifier module, asdl_seq * names, int level, int
  410.                        lineno, int col_offset, PyArena *arena);
  411. #define Exec(a0, a1, a2, a3, a4, a5) _Py_Exec(a0, a1, a2, a3, a4, a5)
  412. stmt_ty _Py_Exec(expr_ty body, expr_ty globals, expr_ty locals, int lineno, int
  413.                  col_offset, PyArena *arena);
  414. #define Global(a0, a1, a2, a3) _Py_Global(a0, a1, a2, a3)
  415. stmt_ty _Py_Global(asdl_seq * names, int lineno, int col_offset, PyArena
  416.                    *arena);
  417. #define Expr(a0, a1, a2, a3) _Py_Expr(a0, a1, a2, a3)
  418. stmt_ty _Py_Expr(expr_ty value, int lineno, int col_offset, PyArena *arena);
  419. #define Pass(a0, a1, a2) _Py_Pass(a0, a1, a2)
  420. stmt_ty _Py_Pass(int lineno, int col_offset, PyArena *arena);
  421. #define Break(a0, a1, a2) _Py_Break(a0, a1, a2)
  422. stmt_ty _Py_Break(int lineno, int col_offset, PyArena *arena);
  423. #define Continue(a0, a1, a2) _Py_Continue(a0, a1, a2)
  424. stmt_ty _Py_Continue(int lineno, int col_offset, PyArena *arena);
  425. #define BoolOp(a0, a1, a2, a3, a4) _Py_BoolOp(a0, a1, a2, a3, a4)
  426. expr_ty _Py_BoolOp(boolop_ty op, asdl_seq * values, int lineno, int col_offset,
  427.                    PyArena *arena);
  428. #define BinOp(a0, a1, a2, a3, a4, a5) _Py_BinOp(a0, a1, a2, a3, a4, a5)
  429. expr_ty _Py_BinOp(expr_ty left, operator_ty op, expr_ty right, int lineno, int
  430.                   col_offset, PyArena *arena);
  431. #define UnaryOp(a0, a1, a2, a3, a4) _Py_UnaryOp(a0, a1, a2, a3, a4)
  432. expr_ty _Py_UnaryOp(unaryop_ty op, expr_ty operand, int lineno, int col_offset,
  433.                     PyArena *arena);
  434. #define Lambda(a0, a1, a2, a3, a4) _Py_Lambda(a0, a1, a2, a3, a4)
  435. expr_ty _Py_Lambda(arguments_ty args, expr_ty body, int lineno, int col_offset,
  436.                    PyArena *arena);
  437. #define IfExp(a0, a1, a2, a3, a4, a5) _Py_IfExp(a0, a1, a2, a3, a4, a5)
  438. expr_ty _Py_IfExp(expr_ty test, expr_ty body, expr_ty orelse, int lineno, int
  439.                   col_offset, PyArena *arena);
  440. #define Dict(a0, a1, a2, a3, a4) _Py_Dict(a0, a1, a2, a3, a4)
  441. expr_ty _Py_Dict(asdl_seq * keys, asdl_seq * values, int lineno, int
  442.                  col_offset, PyArena *arena);
  443. #define ListComp(a0, a1, a2, a3, a4) _Py_ListComp(a0, a1, a2, a3, a4)
  444. expr_ty _Py_ListComp(expr_ty elt, asdl_seq * generators, int lineno, int
  445.                      col_offset, PyArena *arena);
  446. #define GeneratorExp(a0, a1, a2, a3, a4) _Py_GeneratorExp(a0, a1, a2, a3, a4)
  447. expr_ty _Py_GeneratorExp(expr_ty elt, asdl_seq * generators, int lineno, int
  448.                          col_offset, PyArena *arena);
  449. #define Yield(a0, a1, a2, a3) _Py_Yield(a0, a1, a2, a3)
  450. expr_ty _Py_Yield(expr_ty value, int lineno, int col_offset, PyArena *arena);
  451. #define Compare(a0, a1, a2, a3, a4, a5) _Py_Compare(a0, a1, a2, a3, a4, a5)
  452. expr_ty _Py_Compare(expr_ty left, asdl_int_seq * ops, asdl_seq * comparators,
  453.                     int lineno, int col_offset, PyArena *arena);
  454. #define Call(a0, a1, a2, a3, a4, a5, a6, a7) _Py_Call(a0, a1, a2, a3, a4, a5, a6, a7)
  455. expr_ty _Py_Call(expr_ty func, asdl_seq * args, asdl_seq * keywords, expr_ty
  456.                  starargs, expr_ty kwargs, int lineno, int col_offset, PyArena
  457.                  *arena);
  458. #define Repr(a0, a1, a2, a3) _Py_Repr(a0, a1, a2, a3)
  459. expr_ty _Py_Repr(expr_ty value, int lineno, int col_offset, PyArena *arena);
  460. #define Num(a0, a1, a2, a3) _Py_Num(a0, a1, a2, a3)
  461. expr_ty _Py_Num(object n, int lineno, int col_offset, PyArena *arena);
  462. #define Str(a0, a1, a2, a3) _Py_Str(a0, a1, a2, a3)
  463. expr_ty _Py_Str(string s, int lineno, int col_offset, PyArena *arena);
  464. #define Attribute(a0, a1, a2, a3, a4, a5) _Py_Attribute(a0, a1, a2, a3, a4, a5)
  465. expr_ty _Py_Attribute(expr_ty value, identifier attr, expr_context_ty ctx, int
  466.                       lineno, int col_offset, PyArena *arena);
  467. #define Subscript(a0, a1, a2, a3, a4, a5) _Py_Subscript(a0, a1, a2, a3, a4, a5)
  468. expr_ty _Py_Subscript(expr_ty value, slice_ty slice, expr_context_ty ctx, int
  469.                       lineno, int col_offset, PyArena *arena);
  470. #define Name(a0, a1, a2, a3, a4) _Py_Name(a0, a1, a2, a3, a4)
  471. expr_ty _Py_Name(identifier id, expr_context_ty ctx, int lineno, int
  472.                  col_offset, PyArena *arena);
  473. #define List(a0, a1, a2, a3, a4) _Py_List(a0, a1, a2, a3, a4)
  474. expr_ty _Py_List(asdl_seq * elts, expr_context_ty ctx, int lineno, int
  475.                  col_offset, PyArena *arena);
  476. #define Tuple(a0, a1, a2, a3, a4) _Py_Tuple(a0, a1, a2, a3, a4)
  477. expr_ty _Py_Tuple(asdl_seq * elts, expr_context_ty ctx, int lineno, int
  478.                   col_offset, PyArena *arena);
  479. #define Ellipsis(a0) _Py_Ellipsis(a0)
  480. slice_ty _Py_Ellipsis(PyArena *arena);
  481. #define Slice(a0, a1, a2, a3) _Py_Slice(a0, a1, a2, a3)
  482. slice_ty _Py_Slice(expr_ty lower, expr_ty upper, expr_ty step, PyArena *arena);
  483. #define ExtSlice(a0, a1) _Py_ExtSlice(a0, a1)
  484. slice_ty _Py_ExtSlice(asdl_seq * dims, PyArena *arena);
  485. #define Index(a0, a1) _Py_Index(a0, a1)
  486. slice_ty _Py_Index(expr_ty value, PyArena *arena);
  487. #define comprehension(a0, a1, a2, a3) _Py_comprehension(a0, a1, a2, a3)
  488. comprehension_ty _Py_comprehension(expr_ty target, expr_ty iter, asdl_seq *
  489.                                    ifs, PyArena *arena);
  490. #define excepthandler(a0, a1, a2, a3, a4, a5) _Py_excepthandler(a0, a1, a2, a3, a4, a5)
  491. excepthandler_ty _Py_excepthandler(expr_ty type, expr_ty name, asdl_seq * body,
  492.                                    int lineno, int col_offset, PyArena *arena);
  493. #define arguments(a0, a1, a2, a3, a4) _Py_arguments(a0, a1, a2, a3, a4)
  494. arguments_ty _Py_arguments(asdl_seq * args, identifier vararg, identifier
  495.                            kwarg, asdl_seq * defaults, PyArena *arena);
  496. #define keyword(a0, a1, a2) _Py_keyword(a0, a1, a2)
  497. keyword_ty _Py_keyword(identifier arg, expr_ty value, PyArena *arena);
  498. #define alias(a0, a1, a2) _Py_alias(a0, a1, a2)
  499. alias_ty _Py_alias(identifier name, identifier asname, PyArena *arena);
  500.  
  501. PyObject* PyAST_mod2obj(mod_ty t);
  502.