o @axX@s dZddlmZddlmZddlmZdZGdddeZ Gdd d eZ Gd d d e Z Gd d d e Z Gddde Z Gddde ZGddde ZGddde ZGddde ZGdddeZGdddeZGdddeZGdddeZGd d!d!eZGd"d#d#eZGd$d%d%eZGd&d'd'eZGd(d)d)eZGd*d+d+eZGd,d-d-eZGd.d/d/eZGd0d1d1eZGd2d3d3eZGd4d5d5eZ Gd6d7d7eZ!Gd8d9d9eZ"Gd:d;d;eZ#Gdd?d?e#Z%Gd@dAdAeZ&GdBdCdCeZ'dDS)Ez Generator for C/C++. )dedent) pythran_ward)signatures_to_stringz$Copyright (C) 2008 Andreas Kloecknerc@seZdZdddZdS)NopTccs dVdSN)selfwith_semicolonrr0/usr/lib/python3/dist-packages/pythran/cxxgen.pygenerate's z Nop.generateNT__name__ __module__ __qualname__r rrrr r%src@s&eZdZd ddZddZddZdS) DeclaratorTccsp|\}}t|}|ddD]}|Vq|rdnd}|dur,d|d|fVdSd|d||fVdS)N;rz%s%sz%s %s%s) get_decl_pairlist)r r tp_linestp_decllineZscrrr r ,s  zDeclarator.generatecCsdS)aHReturn a tuple ``(type_lines, rhs)``. *type_lines* is a non-empty list of lines (most often just a single one) describing the type of this declarator. *rhs* is the right- hand side that actually contains the function/array/constness notation making up the bulk of the declarator syntax. Nrr rrr r7szDeclarator.get_decl_paircCs.|\}}d|}|dur|Sd||fS)z'Return the declarator as a single line. Nz%s %s)rjoin)r rrrrr inline@s   zDeclarator.inlineNr )rrrr rrrrrr r+s  rc@s eZdZdZddZddZdS)Valuez@A simple declarator: *typename* and *name* are given as strings.cC||_||_dSNtypenamename)r r"r#rrr __init__M zValue.__init__cCs|jg|jfSr r!rrrr rQszValue.get_decl_pairNrrr__doc__r$rrrrr rJs rc@s(eZdZddZeddZddZdS)NestedDeclaratorcC ||_dSr )subdeclr r*rrr r$V zNestedDeclarator.__init__cCs|jjSr )r*r#rrrr r#YszNestedDeclarator.namecCs |jSr r*rrrrr r]r,zNestedDeclarator.get_decl_pairN)rrrr$propertyr#rrrrr r(Us   r(c@eZdZdddZddZdS) DeclSpecifierrcCst||||_||_dSr )r(r$specsep)r r*r1r2rrr r$bs  zDeclSpecifier.__init__cs&fdd}j\}}|||fS)Nc3sNt|}zdjjt|fVWn tyYnw|D]}|VqdS)Nz%s%s%s)iterr1r2next StopIteration)Zsub_ititrrrr add_spechs z-DeclSpecifier.get_decl_pair..add_specr-)r r7sub_tpsub_declrrr rgs  zDeclSpecifier.get_decl_pairN)rrrrr$rrrrr r0a  r0c@eZdZddZdS)TypedefcCst||ddS)NZtypedef)r0r$r+rrr r$wszTypedef.__init__Nrrrr$rrrr r=v r=c@eZdZddZddZdS)FunctionDeclarationcGs"t||d|_||_||_dS)NT)r(r$r arg_decls attributes)r r*rBrCrrr r$|s  zFunctionDeclaration.__init__cCsJ|j\}}|jrdg|}|d|ddd|jDd|jffS)Nrz %s(%s) %s, css|]}|VqdSr )r).0Zadrrr z4FunctionDeclaration.get_decl_pair..r)r*rrrrBrC)r r8r9rrr rs  z!FunctionDeclaration.get_decl_pairNr:rrrr rA{s rAc@s"eZdZdZdddZddZdS)Structa A structure declarator. Attributes ---------- tpname : str Name of the structure. (None for unnamed struct) fields : [Declarator] Content of the structure. inherit : str Parent class of current structure. NcCs||_||_||_dS)z&Initialize the structure declarator. N)tpnamefieldsinherit)r rIrJrKrrr r$s zStruct.__init__csfdd}|dfS)z See Declarator.get_decl_pair.c3sld}jdur|j7}jdur|dj7}|VdVjD]}|D]}d|Vq(q"dVdS)z2 Iterator generating lines for struct definition. zstruct Nz : { z} )rIrKrJr )Zdeclff_linerrr get_tps       z$Struct.get_decl_pair..get_tprr)r rPrrr rs  zStruct.get_decl_pairr r&rrrr rHs rHcs&eZdZfddZdddZZS)Templatectt||||_dSr )superrQr$ template_spec)r rTr* __class__rr r$ zTemplate.__init__FccsJdd|jV|j|D]}|Vqt|jttfs#dVdSdS)Nz template <%s>rDr)rrTr*r isinstancerQrA)r r irrr r s zTemplate.generate)F)rrrr$r __classcell__rrrUr rQs rQc@eZdZdddZddZdS) ExceptHandlerNcC||_||_||_dSr )r#bodyalias)r r#r^r_rrr r$ zExceptHandler.__init__ccsD|jdur dVn d|j|jpdfV|jD]}|VqdS)Nz catch(...)z%catch (pythonic::types::%s const& %s)r)r#r_r^r r rrrr r s zExceptHandler.generater rrrr$r rrrr r\r;r\c@r@) TryExceptcCrr )try_except_)r rdrerrr r$r%zTryExcept.__init__ccsFdV|jD]}|Vq |jD]}|D]}d|VqqdS)NtryrM)rdr re)r rZ exceptionrrr r s   zTryExcept.generateNrbrrrr rc rcc@r[)IfNcCr]r ) conditionthen_else_)r rirjrkrrr r$r`z If.__init__ccsRd|jV|jD]}|Vq |jdur%dV|jD]}|VqdSdS)Nzif (%s)else)rirjr rkrarrr r s  z If.generater rbrrrr rhr;rhc@r@)LoopcCr)r r^r r^rrr r$r,z Loop.__init__ccs&|V|jD]}|Vq dSr ) intro_liner^r rarrr r s  z Loop.generateNrbrrrr rm rmc$eZdZfddZddZZS)WhilecrRr )rSrsr$ri)r rir^rUrr r$rWzWhile.__init__cCs d|jS)Nz while (%s))rirrrr rpr,zWhile.intro_linerrrr$rprZrrrUr rss rscrr)Forcs&tt||||_||_||_dSr )rSrur$startriupdate)r rvrirwr^rUrr r$s z For.__init__cCsd|j|j|jfS)Nzfor (%s; %s; %s))rvrirwrrrr rpszFor.intro_linertrrrUr rus rucrr)AutoForcs tt||||_||_dSr )rSrxr$targetr3)r ryZiter_r^rUrr r$s zAutoFor.__init__cCs*|jdkr d|j|jSd|j|jS)N_z$for (PYTHRAN_UNUSED auto&& {0}: {1})zfor (auto&& {0}: {1}))ryformatr3rrrr rps zAutoFor.intro_linertrrrUr rxs rxc@r@)DefinecCrr symbolvalue)r r~rrrr r$!r%zDefine.__init__ccd|j|jfVdS)Nz #define %s %sr}rrrr r %zDefine.generateNrbrrrr r| rgr|c@r/)IncludeTcCrr )filenamesystem)r rrrrr r$*r%zInclude.__init__ccs(|jr d|jVdSd|jVdS)Nz #include <%s>z #include "%s")rrrrrr r .szInclude.generateNr rbrrrr r)  rc@r@)LabelcCr)r label)r rrrr r$6r,zLabel.__init__cc|jdVdS)Nz:;rrrrr r 9zLabel.generateNrbrrrr r5rqrc@r@) StatementcCr)r textr rrrr r$>r,zStatement.__init__ccr)Nrrrrrr r ArzStatement.generateNrbrrrr r=rqrc@r@)AnnotatedStatementcCrr )stmt annotations)r rrrrr r$Fr%zAnnotatedStatement.__init__ccs@|jD]}d|j}|j|jVq|jD]}|VqdS)Nz#pragma )rsr{Zdepsrr )r Z directiveZpragmarrrr r Js  zAnnotatedStatement.generateNrbrrrr rErgrc@r<)ReturnStatementccsd|jdVdS)Nzreturn rrrrrr r SszReturnStatement.generateNrrrrr rRr?rc@r<)EmptyStatementcCst|ddSr)rr$rrrr r$XzEmptyStatement.__init__Nr>rrrr rWr?rc@r@)AssigncCrr lvaluervalue)r rrrrr r$]r%zAssign.__init__ccr)Nz%s = %s;rrrrr r arzAssign.generateNrbrrrr r\rgrc@r/)LinercCr)r rrrrr r$fr,z Line.__init__ccs|jVdSr rrrrr r is z Line.generateN)rrbrrrr res  rc@r@) FunctionBodycCs||_||_dS)zInitialize a function definition. *fdecl* is expected to be a :class:`FunctionDeclaration` instance, while *body* is a :class:`Block`. N)fdeclr^)r rr^rrr r$os zFunctionBody.__init__ccs6|jjddD]}|Vq|jD]}|VqdS)NF)r )rr r^)r rOZb_linerrr r ws zFunctionBody.generateNrbrrrr rns rc@r[)BlockNcCs|durg}||_dSr )contents)r rrrr r$s zBlock.__init__ccs6dV|jD]}|D]}d|Vq qdVdS)NrLrM}rr r itemZ item_linerrr r s    zBlock.generater rbrrrr rr;rc@r<)Moduleccs&|jD] }|D]}|Vq qdSr r)r crrrr r s   zModule.generateNrrrrr rr?rc@r[) NamespaceNcCst||||_dSr )rr$r#)r r#rrrr r$s  zNamespace.__init__ccsBd|jVdV|jD]}|D]}d|Vqq dVdS)Nz namespace rLrMr)r#rr rrrr r s     zNamespace.generater rbrrrr rrrc@sheZdZdZddZddZddZdd Zd d Zd d Z ddZ ddZ ddZ ddZ ddZdS) PythonModulezO Wraps the creation of a Pythran module wrapped a Python native Module cCsd||_g|_g|_i|_g|_g|_g|_g|_g|_||_ ||_ | |j dd}||j d<dS)z. Builds an empty PythonModule Nr moduledoc) r#preambleincludes functions global_varsimplemscapsulespython_implemswrappers docstringsmetadata docstringget)r r#rrrrrr r$szPythonModule.__init__cCs&|t|ddddddS)N"z\" \n z\r) splitstringrreplacer docrrr rszPythonModule.docstringcCsdd|dS)Nz"{}"z\n""r)r{rsplitrrrr rzPythonModule.splitstringcG|j|dSr )rextend)r parrr add_to_preamblerzPythonModule.add_to_preamblecGrr )rr)r Zinclrrr add_to_includesrzPythonModule.add_to_includescC||j||||dSr )add_function_torr funcr#types signaturerrr add_pyfunctionzPythonModule.add_pyfunctioncCs |j||f|j|dSr )rappendr)r rptrnamesigrrr add_capsuleszPythonModule.add_capsulecCrr )rrrrrr add_functionrzPythonModule.add_functionc Cs||g}g}td|jj}t|D]\} } |d| | |d| | q|jjdt|} ddd| D} t d} |j | j|jj|rPdnd t|d t|dd dt t|Dd |d |ppd|| d |||f}|j |g|dS)ab Add a function to be exposed. *func* is expected to be a :class:`cgen.FunctionBody`. Because a function can have several signatures exported, this method actually creates a wrapper for each specialization and a global wrapper that checks the argument types and runs the correct candidate, if any Zwrap_zfrom_python<{}>(args_obj[{}])z is_convertible<{}>(args_obj[{}])Nrcss|] }d|jVqdS)z"{}", N)r{r#)rEargrrr rFsz/PythonModule.add_function_to..ac static PyObject * {wname}(PyObject *self, PyObject *args, PyObject *kw) {{ PyObject* args_obj[{size}+1]; {silent_warning} char const* keywords[] = {{{keywords} nullptr}}; if(! PyArg_ParseTupleAndKeywords(args, kw, "{fmt}", (char**)keywords {objs})) return nullptr; if({checks}) return to_python({name}({args})); else {{ return nullptr; }} }}z(void)args_obj;Ocss|]}d|VqdS)z, &args_obj[%d]Nr)rErYrrr rFsrDz && 1) r#Zsilent_warningsizeZfmtZobjsargsZcheckswnamekeywords)rrrr# enumerater{rBlenrrrranger setdefault)r torr#ctypesrZ args_unboxingZ args_checks wrapper_namerYtrBrwrapperZfunc_descriptorrrr rs4        zPythonModule.add_function_tocCs,|j||jtd|d|dS)Nzstatic PyObject* z to_python({}))rrrrr{)r r#Zinitrrr add_global_var"s  zPythonModule.add_global_varc Csg}g}g}|jD] }|d|q |jD]`\}}g}g}|D]\} } } tdj| d} || || q#t||} td|}tdj|d|| | dd|d}| |j |d }td j|||d }||||q|jD]\}}d j||d }||q}tdjd dd|Dd}tdjd|jd|d|j}|j|j|jtdg|jdd|j|Dt|t|tdg}dt|S)zRGenerate (i.e. yield) the source code of the module line-by-line. z*PyModule_AddObject(theModule, "{0}", {0});z if(PyObject* obj = {name}(self, args, kw)) return obj; PyErr_Clear(); )r#Zwrapall_a static PyObject * {wname}(PyObject *self, PyObject *args, PyObject *kw) {{ return pythonic::handle_python_exception([self, args, kw]() -> PyObject* {{ {tryall} return pythonic::python::raise_invalid_argument( "{name}", {candidates}, args, kw); }}); }} rr)r#tryall candidatesrrz{{ "{name}", (PyCFunction){wname}, METH_VARARGS | METH_KEYWORDS, {doc}}})r#rrz PyModule_AddObject(theModule, "{ptrname}", PyCapsule_New((void*)&{ptrname}, "{sig}", NULL) );)rrz static PyMethodDef Methods[] = {{ {methods} {{NULL, NULL, 0, NULL}} }}; css|]}|dVqdS),Nr)rEmrrr rFlrGz'PythonModule.__str__..)methodsa #if PY_MAJOR_VERSION >= 3 static struct PyModuleDef moduledef = {{ PyModuleDef_HEAD_INIT, "{name}", /* m_name */ {moduledoc}, /* m_doc */ -1, /* m_size */ Methods, /* m_methods */ NULL, /* m_reload */ NULL, /* m_traverse */ NULL, /* m_clear */ NULL, /* m_free */ }}; #define PYTHRAN_RETURN return theModule #define PYTHRAN_MODULE_INIT(s) PyInit_##s #else #define PYTHRAN_RETURN return #define PYTHRAN_MODULE_INIT(s) init##s #endif PyMODINIT_FUNC PYTHRAN_MODULE_INIT({name})(void) #ifndef _WIN32 __attribute__ ((visibility("default"))) #if defined(GNUC) && !defined(__clang__) __attribute__ ((externally_visible)) #endif #endif ; PyMODINIT_FUNC PYTHRAN_MODULE_INIT({name})(void) {{ import_array() #if PY_MAJOR_VERSION >= 3 PyObject* theModule = PyModule_Create(&moduledef); #else PyObject* theModule = Py_InitModule3("{name}", Methods, {moduledoc} ); #endif if(! theModule) PYTHRAN_RETURN; PyObject * theDoc = Py_BuildValue("(sss)", "{version}", "{date}", "{hash}"); if(! theDoc) PYTHRAN_RETURN; PyModule_AddObject(theModule, "__pythran__", theDoc); {extraobjects} PYTHRAN_RETURN; }} )r#Z extraobjectsz#ifdef ENABLE_PYTHON_MODULEcSsg|]}t|qSr)r)rEcoderrr sz(PythonModule.__str__..z#endifNr)rrr{ritemsrrrrrrrrrrr#rrrrrrrrr )r Z themethodsZtheextraobjectsZ theoverloadsZvnamefnameZ overloadsrZ signaturesZoverloadrrrdrr candidatefdocZ themethodrrZcapsulermoduler^rrr __str__'s          668:zPythonModule.__str__N)rrrr'r$rrrrrrrrrrrrrr rs7 rc@r@)CompilationUnitcCr)r rnrorrr r$r,zCompilationUnit.__init__cCsddd|jDS)Nrcss|] }d|VqdS)rN)rr )rErrrr rFsz*CompilationUnit.__str__..)rr^rrrr rrzCompilationUnit.__str__N)rrrr$rrrrr rs rN)(r'textwraprZpythran.tablesrZ pythran.specrZ __copyright__objectrrrr(r0r=rArHrQr\rcrhrmrsrurxr|rrrrrrrrrrrrrrrrrr sJ     (        (x