]c@shddlmZddlZddlZddlZddlZddlZddlZddl Zddl j Z ddl Zga ddlmZdefdYZdefdYZdZejd ejZd Zd Zd Zd aededZdZe dddddddddddddddd d!d"d#d$d%d&gZ!d'd(d)d*d+d,d-d.d/d0d1d2d3d4d5d6d7d8d9d:gZ"d;d<d=d>d?gZ#d0j$ge"D]Z%ej&e%^qe#Z'd@Z(dAZ)dBefdCYZ*dDefdEYZ+eedFZ,dGZ-dHZ.dIZ/dJZ0dKZ1dLZ2dMefdNYZ3e3Z4dOZ5e5ddPZ6e5d$dQZ7e5dRdSZ8e5ddTZ9e5d dUZ:e5ddVZ;e5ddWZ<e5d!dXZ=e5d"dYZ>e5dZd[Z?e5dd\Z@e5d#d]ZAe5dd^ZBe5d_d`ZCe5dadbZDe5d&dcZEe5dddZFe5ddeZGe5dfedgZHe5dhdiZIe5djdkZJe5ddlZKe5dmdnZLdoZMdpZNeOejPjQdqdrZRe5dsdtZSe5dudvZTdwZUe5dxdyZVe5dzd{ZWeed|ZXd}ZYe5d d~ZZdZ[dZ\eddZ]dZ^dZ_dS(i(tprint_functionN(tmatch_logical_wordt ParseErrorcBs#eZddedZdZRS(c Csdt|||f}|rt|tr@dj|}n|jd}t|dkr d} d} x| t|dkr|d| } | dkr| d7} nK| | krd} n6| rn-| dks| dks| d kr| } n| d7} qpW| r |d | 7}q nxy|D]n} |d | 7}|dk r|t| krx|d d |d 7}d}q|t| 8}n|r'Pq'q'Wn||_tj ||dS(NuFile "%s", line %d: %sts iis\t`s't"s: (Perhaps you left out a %s at the end of the first line.)s t t^( tunicode_filenamet isinstancetlisttjointsplittlentNonetmessaget Exceptiont__init__( tselftfilenametnumbertmsgtlinetpostfirstRtlinest open_stringtitctl((srenpy/parser.pyR.s@    $      cCs|jS(N(R(R((srenpy/parser.pyt __unicode__]sN(t__name__t __module__RtFalseRR(((srenpy/parser.pyR,s/tLineNumberHoldercBseZdZdZRS(s) Holds the expected line number. cCs d|_dS(Ni(R(R((srenpy/parser.pyRhs(RR t__doc__R(((srenpy/parser.pyR"cscCsVt|tr|Sy|jdSWnnXy|jdSWnnX|jdS(s4 Converts the supplied filename to unicode. tmbcssutf-8slatin-1(R tunicodetdecode(tfn((srenpy/parser.pyRlss__(\w+)|\w+| +|.cCsdtjj|}tjj|d}|jdd}d}tjd||}d|dS(NiRt_cSstt|jdS(Ni(thextordtgroup(tm((srenpy/parser.pyt munge_charss [^a-zA-Z0-9_]t_m1_t__(tostpathtbasenametsplitexttreplacetretsub(R'trvR-((srenpy/parser.pytmunge_filenames  cCs|}tjj|}tjjtjj}tjjtjj}|j|rvtjj||j ddS|j|rtjj||j ddS|j ddSdS(sy Returns a version of fn that is either relative to the base directory, or relative to the Ren'Py directory. s\t/N( R0R1tabspathtrenpytconfigtbasedirt renpy_baset startswithtrelpathR4(R'tofnR=R>((srenpy/parser.pytelide_filenamescCsftjjtjj|}tjj|r1|Stjjtjj|}tjj|rb|S|S(N(R0R1R R;R<R=texistsR>(R'tfn1tfn2((srenpy/parser.pytunelide_filenamesRicsnfd}|a|r$|}n.t|d}|jjd}|jt|}t||d7}g}|}d} t|r|ddkr| d7} n|stj j j rtj j } ni} t|} tj jj|xE| | krB|} g} d}|| f}tj jt| | | || }|| }|dkrt||d n|d kr| rd j| } tjd | s|j|| | fn|dkr| }n|d| |_x"||dd kr!|d8}qW|| |_|| |j| |j!| |_|| |j| |j!| |_| d7} |d7}d}g} Pn|d kr|d7}d}n|dkr| d7} qMn|dkr|| dd kr| d7} |d7}| jdqMn|dkr2|d7}n|dkrQ|rQ|d8}n|dkr| }x|| d kr| d7} qfWqMn|dkr|}| j|| d7} t}t}| | dkr || |kr || d|kr | j|| j|| d7} t}ng}xD| | krl|| }|d krX|d7}n|dkrt| d7} q)n|rt}| d7} |j|q)n||kr:|s| d7} |j|Pn| | dkr:|| d|kr:|| d|kr:| d7} |j||j||j|Pq:n|dkrOt}n|j|| d7} q)q)Wd j|}d|krtjd||}n| j|qMnt|| \}}}|r|d}d|kr|}qn| j||} | |dkrMt|| dd| dtqMqMWqW| rjt|| dd| dtn|S( s Reads `filename`, and divides it into logical lines. Returns a list of (filename, line number, line text) triples. If `filedata` is given, it should be a unicode string giving the file contents. In that case, `filename` need not exist. csi|jd}t|d@dkr2|jdSd|jdkrT|jdS||jdS(NiiR/i(R+R (R,tbrackets(tprefix(srenpy/parser.pyt munge_strings   trbsutf-8s iuiu s1Tab characters are not allowed in Ren'Py scripts.u Ru^\s*$u u u\iu\ u([{u}])u#u"'`is[__s(\.|\[+)__(\w+)u__is:Overly long logical line. (Check strings and parenthesis.)RRsBis not terminated with a newline. (Check strings and parenthesis.)N( toriginal_filenametopentreadR&tcloseRBR8R R;tgametcontextt init_phaset scripteditRtfilestaddtLineRRR R5tmatchtappendt end_delimtendtstartttextt full_textR!tTrueR6R(Rtfiledatat linenumbert add_linesRItdatatfR7RRRtlen_datat start_numberRt parendepthtloctendpoststartposRtdelimtescapet triplequotetstwordtmagicRYtrest((RHsrenpy/parser.pytlist_logical_liness               ""                  4              8             )!cs/dfddddS(sE This takes as input the list of logical line triples output from list_logical_lines, and breaks the lines into blocks. Each block is represented as a list of (filename, line number, line text, block) triples, where block is a block list (which may be empty if no block is associated with this line.) cSsRd}d}x5trC||dkr?|d7}|d7}qnPqW|||fS(NiRi(R](Rtdepthtindex((srenpy/parser.pyt depth_splits   c sg}d}x|tkr|\}}}|\}}||krVPn|dkrk|}n||krt||dn|d7}||d\} }|j|||| fqW||fS(Nsindentation mismatch.i(RR RRW( Rt min_depthR7RqRRR[t line_depthRotblock(Rstgll_coreR(srenpy/parser.pyRws     i((R((RsRwRsrenpy/parser.pytgroup_logical_liness t$tastattbehindtcallt expressionthidetiftintimagetinittjumptmenutonlayertpythontreturntscenetshowtwithtwhiletzordert transforms<>s<>s>=t>s!=s==t|Rt&t+t-s**t*s//R9t%t~s\bor\bs\band\bs\bnot\bs\bin\bs\bis\bu"[a-zA-Z_ -�][0-9a-zA-Z_ -�]*u'[-0-9a-zA-Z_ -�][-0-9a-zA-Z_ -�]*tSubParsecBs eZdZdZdZRS(ss This represents the information about a subparse that can be provided to a creator-defined statement. cCs ||_dS(N(Rv(RRv((srenpy/parser.pyR0scCs5|js dSdj|jdj|jdjSdS(Nssi(RvtformatRR_(R((srenpy/parser.pyt__repr__3s (RR R#RR(((srenpy/parser.pyR*s tLexercBseZdZedd0dd0dZdZdZdZdZ dZ d Z e j d Zd Zd Zd ZdZdZdZedZdZdZdZdZdZdZdZdZedZdZdZ dZ!dZ"dZ#e$d Z%e$d!Z&d"Z'ee$d#Z(d$Z)d%Z*d&Z+d'Z,d(Z-d0d)Z.d*Z/d+Z0d,Z1d-Z2d.Z3ed/Z4RS(1s The lexer that is used to lex script files. This works on the idea that we want to lex each line in a block individually, and use sub-lexers to lex sub-blocks. is cCs||_||_||_t|_d|_d|_d|_d|_g|_ ||_ d|_ d|_ d|_ d|_||_||_dS(NiRi(Rt init_offsetRvR!teobRRR[Rtsubblockt global_labelRtword_cache_postword_cache_newpost word_cachetmonologue_delimitert subparses(RRvRRRRR((srenpy/parser.pyRBs                cCsr|jd7_|jt|jkr4t|_tS|j|j\|_|_|_|_ d|_ d|_ tS(s' Advances this lexer to the next line in the block. The lexer starts off before the first line, so advance must be called before any matching can be done. Returns True if we've successfully advanced to a line in the block, or False if we have advanced beyond all lines in the block. In general, once this method has returned False, the lexer is in an undefined state, and it doesn't make sense to call any method other than advance (which will always return False) on the lexer. iii( RR RvR]RR!RRR[RRR(R((srenpy/parser.pytadvance^s  (  cCs_|jd8_t|_|j|j\|_|_|_|_t|j|_ d|_ dS(s Puts the parsing point at the end of the previous line. This is used after renpy_statement to prevent the advance that Ren'Py statements do. iiN( RR!RRvRRR[RR RR(R((srenpy/parser.pyt unadvancevs  (cCsv|jr dS|jt|jkr)dStj|tjj|j|j}|sZdS|j |_|j dS(s Tries to match the given regexp at the current location on the current line. If it succeds, it returns the matched text (if any), and updates the current position to be after the match. Otherwise, returns None and the position is unchanged. iN( RRRR R[R5tcompiletDOTALLRVRYR+(RtregexpR,((srenpy/parser.pyt match_regexps 'cCs|jddS(sQ Advances the current position beyond any contiguous whitespace. u (\s+|\\\n)+N(R(R((srenpy/parser.pytskip_whitespacescCs|j|j|S(s Matches something at the current position, skipping past whitespace. Even if we can't match, the current position is still skipped past the leading whitespace. (RR(RR((srenpy/parser.pyRVs cCs,|j}|j|kr|S||_dS(s Matches a keyword at the current position. A keyword is a word that is surrounded by things that aren't words, like whitespace. (This prevents a keyword from matching a prefix.) R(RRm(RRmtoldpos((srenpy/parser.pytkeywords   ccs3y dVWn#tk r.}tj|jnXdS(sm Catches errors, then causes the line to advance if it hasn't been advanced already. N(Rt parse_errorsRWR(Rte((srenpy/parser.pyt catch_errors cCs(t|j|j||j|jdS(sc Convenience function for reporting a parse error at the current location. N(RRRR[R(RR((srenpy/parser.pyterrorscCs |j|jt|jkS(s Returns True if, after skipping whitespace, the current position is at the end of the end of the current line, or False otherwise. (RRR R[(R((srenpy/parser.pyteols cCs |js|jdndS(sG If we are not at the end of the line, raise an error. send of line expected.N(RR(R((srenpy/parser.pyt expect_eols cCs7|jr3|j}|j|jd|ndS(sz Called to indicate this statement does not expect a block. If a block is found, raises an error. soLine is indented, but the preceding %s statement does not expect a block. Please check this line's indentation.N(Rtsubblock_lexerRR(Rtstmttll((srenpy/parser.pytexpect_noblocks   cCs!|js|jd|ndS(sk Called to indicate that the statement requires that a non-empty block is present. s%s expects a non-empty block.N(RR(RR((srenpy/parser.pyt expect_blocks cCs t|jS(sL Called to check if the current line has a non-empty block. (tboolR(R((srenpy/parser.pyt has_blocksc CsF|jp |}t|jd|d|jd|jd|jd|jS(sk Returns a new lexer object, equiped to parse the block associated with this line. RRRRR(RRRRRRR(RR((srenpy/parser.pyRscCs|jd}|d kr-|jd}n|d krK|jd}n|d kr[d S|ddkr~t}|d}nt}|dd!}d}|stjd d |}tjd ||}n|S( s' Lexes a string, and returns the string to the user, or None if no string could be found. This also takes care of expanding escapes and collapsing whitespace. Be a little careful, as this can return an empty string, which is different than None. sr?"([^\\"]|\\.)*"sr?'([^\\']|\\.)*'sr?`([^\\`]|\\.)*`itriicSs|jd}|dkrdS|dkr/dS|dkr?dS|dkrOd S|d d kr|jd }|rtt|jd d Sn|SdS(Nit{s{{t[s[[Rs%%tns ituii(R+tunichrtint(R,Rtgroup2((srenpy/parser.pytdequote#s    s\s+Rs\\(u([0-9a-fA-F]{1,4})|.)N(RVRR]R!R5R6(RRltrawR((srenpy/parser.pytstrings"       cCs/|jd}|dkr-|jd}n|dkrK|jd}n|dkr[dS|ddkr~t}|d}nt}|dd!}d }|s+tjd d |}g}xi|j|jD]U}|j}|sqntjd d |}tjd||}|j |qW|S|S(s Lexes a triple quoted string, intended for use with monologue mode. This is about the same as the double-quoted strings, except that runs of whitespace with multiple newlines are turned into a single newline. sr?"""([^\\"]|\\.)*"""sr?'''([^\\']|\\.)*'''sr?```([^\\`]|\\.)*```iRiiicSs|jd}|dkrdS|dkr/dS|dkr?dS|dkrOd S|d d kr|jd }|rtt|jd d Sn|SdS(NiRs{{Rs[[Rs%%Rs iRii(R+RR(R,RR((srenpy/parser.pyRZs    s *\n *s s\s+Rs\\(u([0-9a-fA-F]{1,4})|.)N( RVRR]R!R5R6R RtstripRW(RRlRRR7((srenpy/parser.pyt triple_string>s2       cCs |jdS(sf Tries to parse an integer. Returns a string containing the integer, or None. s (\+|\-)?\d+(RV(R((srenpy/parser.pytintegerscCs |jdS(sk Tries to parse a number (float). Returns a string containing the number, or None. s((\+|\-)?(\d+\.?\d*|\.\d+)([eE][-+]?\d+)?(RV(R((srenpy/parser.pytfloatscCs |jdS(sG Matches the characters in an md5 hash, and then some. s\w+(RV(R((srenpy/parser.pythashscCsY|j|jkr%|j|_|jS|j|_|jt}||_|j|_|S(s? Parses a name, which may be a keyword or not. (RRRRRVt word_regexp(RR7((srenpy/parser.pyRms    cCsz|j}|j}|dks-|dkr]|j|j|jd!dkr]||_dSn|tkrv||_dS|S( sG This tries to parse a name. Returns the name or None. RRiRt'R(RRRN(RRmR[RtKEYWORDS(RRR7((srenpy/parser.pytnames      cCs3|r/|ddkr/|jdd|_ndS(s Set current global_label, which is used for label_name calculations. label can be any valid label or None, but this has only effect if label has global part. it.N(R R(Rtlabel((srenpy/parser.pytset_global_labelscCs|j}d}|j}|ss|jd s;|j rH||_dS|j}|j}|s||_dSnS|jdr|r||jkr||_dS|j}|s||_dSn|s|S|d|S(s Try to parse label name. Returns name in form of "global.local" if local is present, "global" otherwise; or None if it doesn't parse. If declare is True, allow only such names that are valid for declaration (e.g. forbid global name mismatch) s\.RN(RRRRVR(Rtdeclaretold_post local_namet global_name((srenpy/parser.pyt label_names.         cCs|jdtS(s> Same as label_name, but set declare to True. R(RR](R((srenpy/parser.pytlabel_name_declarescCs}|j}|jt}|dks0|dkr`|j|j|jd!dkr`||_dSn|tkry||_dS|S( s Matches a word that is a component of an image name. (These are strings of numbers, letters, and underscores.) RRiRRR(RRRN(RRVtimage_word_regexpR[RR(RRR7((srenpy/parser.pytimage_name_components     cCs7|jrtS|j|j}|dkr|jd7_|jt|jkrf|jd8_tS|j|j}|dkr|jd8_tSn|dkrtS|}xstr#|jd7_|jr|jdn|j|j}||krPn|dkr|jd7_qqW|jd7_tS( s This tries to match a python string at the current location. If it matches, it returns True, and the current position is updated to the end of the string. Otherwise, returns False. RiRRs)end of line reached while parsing string.s\(RR(RR(RR!R[RR R]R(RRRi((srenpy/parser.pyt python_strings4        cCs`|j}|sdSxC|jdr[|j}|sJ|jdn|d|7}qW|S(sQ This tries to match a dotted name, which is one or more names, separated by dots. Returns the dotted name if it can, or None if it cannot. Once this sees the first name, it commits to parsing a dotted_name. It will report an error if it then sees a dot without a name behind it. s\.sexpecting name.RN(RRRVR(RR7R((srenpy/parser.pyt dotted_name9s  cCs&|s |Stjj||j|jS(N(R;tasttPyExprRR(RRltexpr((srenpy/parser.pyRRscCs|j}x|js|j|j}||krQ|j|j||j!|S|dkrm|jq n|jrq n|jd7_q W|jd|dS(s# This matches python code up to, but not including, the non-whitespace delimiter characters. Returns a string containing the matched code, which may be empty if the first thing is the delimiter. Raises an error if EOL is reached before the delimiter. s'"is(reached end of line when expecting '%s'.N(RRR[RRtparenthesised_pythonR(RRiRRZR((srenpy/parser.pytdelimited_pythonXs     cCsD|jdt}|s(|jdn|j|j|}|S(sk Returns a python expression, which is arbitrary python code extending to a colon. t:sexpected python_expression(RR!RRR(RRtpeR7((srenpy/parser.pytpython_expressionts cCs|j|j}|dkrN|jd7_|jdt|jd7_tS|dkr|jd7_|jdt|jd7_tS|dkr|jd7_|jdt|jd7_tStS(s Tries to match a parenthesised python expression. If it can, returns true and updates the current position to be after the closing parenthesis. Returns False otherwise. t(it)Rt]Rt}(R[RRR!R](RR((srenpy/parser.pyRs"   cCsW|j}x trx|jtr'qW|jr8Pn|jpe|jpe|jpe|jslPnxntr|j |jrPn|jdr|j }|so|j dqoqon|jrqonPqoW|r|jtrq n|r|jdrq nPq W|j ||j!j }|s;dStjj||j|jS(so Tries to parse a simple_expression. Returns the text if it can, or None if it cannot. s\.sexpecting name after dot.t,N(RR]RVtoperator_regexpRRRRRRRmRR[RRR;RRRR(RtcommatoperatorRZRR[((srenpy/parser.pytsimple_expressions@            cCs|jdtS(st One or more simple expressions, separated by commas, including an optional trailing comma. R(RR](R((srenpy/parser.pytcomma_expressionscCs|jdtS(s= Parses the name portion of a say statement. R(RR!(R((srenpy/parser.pytsay_expressionscCs(|j|j|j|j|j|jfS(s Returns an opaque representation of the lexer state. This can be passed to revert to back the lexer up. (RRRR[RR(R((srenpy/parser.pyt checkpointscCsd|\|_|_|_|_|_|_d|_|jt|jkrWt |_ n t |_ dS(s Reverts the lexer to the given state. State must have been returned by a previous checkpoint operation on this lexer. iN( RRRR[RRRR RvR!RR](Rtstate((srenpy/parser.pytreverts *  cCs|j|jfS(s Returns a (filename, line number) tuple representing the current physical location of the start of the current logical line. (RR(R((srenpy/parser.pyt get_locationscCslt|tr-|p|}|j|}n|p<|jj}|}|dkrh|jd|n|S(s Tries to parse thing, and reports an error if it cannot be done. If thing is a string, tries to parse it using self.match(thing). Otherwise, thing must be a method on this lexer object, which is called directly. sexpected '%s' not found.N(R t basestringRVtim_funct func_nameRR(RtthingRR7((srenpy/parser.pytrequires    cCsN|j|j}t|j|_tjj|j|j|j|j S(s Skips whitespace, then returns the rest of the current line, and advances the current position to the end of the current line. ( RRR R[R;RRRRR(RR((srenpy/parser.pyRos  cCs,|j}t|j|_|j|jS(sG Like rest, but returns a string rather than a PyExpr. (RR R[R(RR((srenpy/parser.pytrest_statement*s csMgt|j_fd|jddjS(s Returns the subblock of this code, and subblocks of that subblock, as indented python code. This tries to insert whitespace to ensure line numbers match up. csx|D]\}}}}x3j|krNj|djd7_qW||d}j|j|jd7_||dqWdS(Ns is (RRWtcount(Rvtindentt_fntlnR[Rtlinetext(totprocessR7(srenpy/parser.pyR?s R(R"RRRR (R((RRR7srenpy/parser.pyt python_block3s   cCs t|S(so Returns an Argument object if there is a list of arguments, or None there is not one. (tparse_arguments(R((srenpy/parser.pyt argumentsQscCso|jdkrtdnt|}|jt|tsO|g}nt|}|jj||S(s Parses the remainder of the current line as a statement in the Ren'Py script language. Returns a SubParse corresponding to the AST node generated by that statement. sHA renpy_statement can only be parsed inside a creator-defined statement.N( RRRtparse_statementRR R RRW(RRvtsp((srenpy/parser.pytrenpy_statementYs    cCs|jdkrtdn|jdkr:|jng}xy|jsy<t|}t|trz|j |n |j |WqCt k r}t j |j |jqCXqCW|s|r|j tj|jq|jdnt|}|jj ||S(NsDA renpy_block can only be parsed inside a creator-defined statement.is*At least one Ren'Py statement is expected.(RRRRRRRR R textendRWRRRRtPassRRR(RtemptyRvRRR((srenpy/parser.pyt renpy_blockns*    N(5RR R#R!RRRRRRRVRt contextlibtcontextmanagerRRRRRRRRRRRRRRmRRRRRRRRR]RRRRRRRRRRRoRRRRR (((srenpy/parser.pyR;s\       9 E      (   1     =        c Cs;|jg}|j|jg}xPtrv|j|j|j}|s`|jPn|j|jq'W|r|j|j|j}|dk r|jt |q|jn|r1x]t ||D]I\}}|r|ddkr|j ||j |j dqqWnt|S(so This parses an image name, and returns it as a tuple. It requires that the image name be present. iRs/image name components may not begin with a '-'.N(RRRR]RWtpopRRRR%tzipRRRttuple( RRtnodashtpointsR7RRlRtp((srenpy/parser.pytparse_image_names,        cCs\|j|jg}x@trW|jds1Pn|j}|sGPn|j|qW|S(s This parses a comma-separated list of simple_expressions, and returns a list of strings. It requires at least one simple_expression be present. R(RRR]RVRW(RR7R((srenpy/parser.pytparse_simple_expression_lists  c Csd}d}g}d}g}|jds<|jdr`|j|j}|jf}nt|t}d}xitr|jdr|r|jdqx|j|j}qxn|jdr|r|jdqxt |}qxn|jdr/|r|jdqx|j|j}qxn|jd rr|dk rZ|jd qx|j|j}qxn|jd r|r|jd nx<tr|j|j}|j ||j d sPqqWqxnPqxW|||||||fS(s) This parses an image specifier. R~RRs(multiple onlayer clauses are prohibited.R{s#multiple at clauses are prohibited.Rzs#multiple as clauses are prohibited.Rs'multiple zorder clauses are prohibited.R|s'multiple behind clauses are prohibited.RN( RRRRRRR]RRRRWRV( Rttagtlayertat_listRR|R~t image_nametbhtag((srenpy/parser.pytparse_image_specifiersT     cCsY|j}|jds|S|j|j}tj|d||tj||gS(s Tries to parse the with clause associated with this statement. If one exists, then the node is wrapped in a list with the appropriate pair of With nodes. Otherwise, just returns the statement by itself. RR(RRRRRtWith(RtnodeRfR((srenpy/parser.pyt parse_withs c CsY|j}t}t}t}d}d}d} d} g} g} x`|jr|jdr|j|j}|j|jdqEn|jdr|j|j}|j|jdqEn|j } |j}|j }|dk rd|dk rd|j|jd|r6|j dn|rL|j dnt }|} |} qEn|j | |j }|dkr|j dn|jr|jr|j d n|r|r|j d n|rt }n| j|d df| jdqEnt }d }| jt||jd rU|j|j}n|jd |j|jdt|j}| j|||fqEW|s|j dng}|r|jtj|| | ddtn|jtj|| |||p||| x5t|D]'\}}|rHd|_q*d|_q*W|S(NRs with clausetsets set menuitems say menuitems:Say menuitems and captions may not exist in the same menu.s)Only one say menuitem may exist per menu.sexpected menuitemslLine is followed by a block, despite not being a menu choice. Did you forget a colon at the end of the line?s:Captions and say menuitems may not exist in the same menu.R]RRschoice menuitems"Menu does not contain any choices.tinteracttnormaltforce(RR!RRRRRRRRRRR]RRRRWRRRt parse_blockRtSaytMenut enumeratetrollback(tstmtlRfRRt has_choicethas_sayt has_captiontwith_Rtsay_whotsay_whattitemstitem_argumentsRtwhotwhatRt conditionRvR7RrR((srenpy/parser.pyt parse_menu/s                     (.  c Csg}g}d}d}t}t}|jds:dSxtr|jdrVPn|jdr|dk r|jdn|j|j}||kr|jd|n|j|n|jdr9|s|jdnt}|j}|dk r||kr&|jd|n|j|qn|j|j}||krk|jd|n|j||jdr|j |j d }nd}|j ||f|r|j |n|jdrPn|jd q=Wt j j||||S( Ns\(s\)s\*\*s&a label may have only one ** parametersparameter %s appears twice.s\*s%a label may have only one * parametert=s),R(RR]RRVRRRRTR!RRRWR;Rt ParameterInfo( Rt parameterst positionaltextrapostextrakwtadd_positionaltnamesRtdefault((srenpy/parser.pytparse_parameterssT          cCs^g}d }d }|jds%d Sx trG|jdrAPn|jdr~|d k rl|jdn|jd}n|jdr|d k r|jdn|jd}ni|j}|j}|o|jds|j|d }n|j|j ||jdf|jdr7Pn|j d q(Wt j j |||S( s7 Parse a list of arguments, if one is present. s\(s\)s\*\*s$a call may have only one ** arguments),s\*s#a call may have only one * argumentR3RN(RRVR]RRRRRRRWRR;Rt ArgumentInfo(RRR8R7RR((srenpy/parser.pyRs6        t ParseTriecBs)eZdZdZdZdZRS(sI This is a trie of words, that's used to pick a parser function. cCsd|_i|_dS(N(RR;twords(R((srenpy/parser.pyR+s cCsd|s||_dS|d}|d}||jkrIt|j|RT(RRtfunctionRRo((srenpy/parser.pyRT/s   cCsW|j}|jp!|jd}||jkrC||_|jS|j|j|S(Ns\$(RRmRVR?R;tparse(RRRRm((srenpy/parser.pyRA=s   (RR R#RRTRA(((srenpy/parser.pyR>&s  csjfd}|S(s A function decorator used to declare a statement. Keywords is a string giving the keywords that precede the statement. cstj||S(N(t statementsRT(Rb(tkeywords(srenpy/parser.pytwrapUs(R (RCRD((RCsrenpy/parser.pyt statementMs cCs[g}|j|j}|jd|j|jdt|j}|j||f|jxx|jdr|j|j}|jd|j|jdt|j}|j||f|jqnW|jdrK|jd|j|jdt|j}|jd|f|jnt j ||S(NRs if statementtelifs elif clausetelses else clauseR]( RRRRR!RRWRRRtIf(RRftentriesR1Rv((srenpy/parser.pyt if_statement_s0           cCse|j|j}|jd|j|jdt|j}|jtj|||S(NRswhile statement( RRRRR!RRRtWhile(RRfR1Rv((srenpy/parser.pytwhile_statements    tpasscCs.|jd|j|jtj|S(Nspass statement(RRRRR(RRf((srenpy/parser.pytpass_statements   cCs|jd|j}|j|t|}|jd|jt|||}|jg}|r|jt j ||gdn|j ||S(Nsmenu statementR( RRRRRRR2RRWRtLabelRR(RRfRRRR7((srenpy/parser.pytmenu_statements       " cCsL|jd|j}|s(d}n|j|jtj||S(Nsreturn statement(RRoRRRRtReturn(RRfRo((srenpy/parser.pytreturn_statements     cCsv|jd|jdr7t}|j|j}nt}|j|j}|j|jt j |||S(Nsjump statementR~( RRR]RRR!RRRRtJump(RRfR~ttarget((srenpy/parser.pytjump_statements   cCsd|jd|jdr7t}|j|j}nt}|j|j}|jdt|}tj ||||g}|jdr|j|j }|j tj ||gdnptjjr6|tjjkr6|rtjjdttjj|jq6tjj|ttjj|jn|j tj||j|j|S(Ns call statmentR~RMtfrom(RRR]RRR!RRRtCallRRWRORR;RRRtadd_fromtreport_missingRKRYRRR(RRfR~RTRR7R((srenpy/parser.pytcall_statements(   "&&  cCs|jdr$|j|j}nd}|jrS|jtj|d|St|}tj|||d}t ||}|j drt j j |j|_ n |jd|j|j|S(NRtmasteriRsscene statement(RRRRRRtSceneRRRRVR;tatlt parse_atlRRR(RRfRtimspecRR7((srenpy/parser.pytscene_statements      cCst|}tj||}t||}|jdrZtjj|j|_n |j d|j |j |S(NRsshow statement( RRtShowRRVR;R]R^RRRR(RRfR_RR7((srenpy/parser.pytshow_statements    s show layercCs|j|j}|jdr0t|}ng}|jdr`tjj|j}nd}|j d|j |j t j||||}|S(NR{Rsshow layer statement(RRRRRVR;R]R^RRRRRRt ShowLayer(RRfRRR]R7((srenpy/parser.pytshow_layer_statement)s   cCsLt|}t|tj||}|j|jd|j|S(Nshide statement(RRRtHideRRR(RRfR_R7((srenpy/parser.pythide_statementAs     cCsC|j|j}|j|jd|jtj||S(Nswith statement(RRRRRRR(RRfR((srenpy/parser.pytwith_statementMs    cCst|dt}|jdrL|jd}tjj|j}nB|j d|j }|s{|j dnd}|j dt j||||}|jst j||gd|j}n|j|S(NRRR3sexpected expressionsimage statementi(RR]RVRRR;R]R^RRRoRRRtImageRtInitRR(RRfRRR]R7((srenpy/parser.pytimage_statementWs      " tdefinecCs|j}|r!t|}nd}d}|j|j}x3|jdrt|d|}|j|j}qBW|jd|j}|s|jdn|jdtj ||||}|j stj ||g||j }n|j |S(Nitstores\.RR3sexpected expressionsdefine statement(RRRRmRVRoRRRtDefineRRiRR(RRftpriorityRlRRR7((srenpy/parser.pytdefine_statementts&     " R;cCs|j}|r!t|}nd}d}|j|j}x3|jdrt|d|}|j|j}qBW|jd|j}|s|jdn|jdtj ||||}|j stj ||g||j }n|j |S(NiRls\.RR3sexpected expressionsdefault statement(RRRRmRVRoRRRtDefaultRRiRR(RRfRnRlRRR7((srenpy/parser.pytdefault_statements&     " cCs|j}|r!t|}nd}|j|j}t|}|rm|js]|jrm|jdn|jd|jt j j |j }t j||||}|jst j||g||j}n|j|S(NisAtransform statement does not take a variable number of parametersR(RRRRR<R8R7RRR;R]R^RRt TransformRRiRR(RRfRnRR5R]R7((srenpy/parser.pyttransform_statements      " cCsO|j}|s"|jdn|jd|jtj||ddS(Nsexpected python codesone-line python statementRl(RRRRRtPython(RRft python_code((srenpy/parser.pytone_line_pythons    cCst}t}d}|jdr*t}n|jdrBt}n|jdrjd|j|j}n|jd|j|jd|j}|j|rt j |||d|St j |||d|SdS(NRltearlyRRsstore.Rs python block( R!RR]RRRRRRRt EarlyPythonRt(RRfRRwRlRu((srenpy/parser.pytpython_statements"       RcCs|j|j}|j|t|}|jdrCt}nt}|jd|jt|j |}|j t j ||||d|S(NRR( RRRR<RR]R!RR!RRRRO(RRfRRR5RRv((srenpy/parser.pytlabel_statement s      s init offsetcCsS|jd|j|j}|j|jd|jt||_gS(NR3sinit offset statement(RRRRRRR(RRftoffset((srenpy/parser.pytinit_offset_statement s    s init labelcCst||dtS(NR(RzR](RRf((srenpy/parser.pytinit_label_statement& scCs|j}|r!t|}nd}|jdro|j|jdt|jt}|jn2z%|j }t|_ t |g}Wd||_ Xt j ||||j S(NiRsinit statement(RRRVRRR!RR]RRRRRiR(RRfRRnRvtold_init((srenpy/parser.pytinit_statement+ s       s rpy monologuecCsh|jdrd|_n(|jdr6d|_n |jd|j|jd|jgS(Ntdoubles tsingles s.rpy monologue expects either single or double.s rpy monologue(RRRRRR(RRf((srenpy/parser.pyt rpy_statementL s      cCsgtjj|}|j|s&gStj||}|jsctj||gd|j}n|S(Ni ( R;t screenlangt parse_screenRRtScreenRRiR(RRftscreenR7((srenpy/parser.pytscreen1_statement] s  "cCsctjjj||}|jtj||}|js_tj||gd|j }n|S(Ni ( R;tsl2tslparserRRRRRRiR(RRfRR7((srenpy/parser.pytscreen2_statementp s   "tRENPY_SCREEN_LANGUAGEt2RcCspt}|j}|dk r-t|}n|dkrFt||S|dkr_t||S|jddS(NiisBad screen language version.(tdefault_screen_languageRRRRRR(RRftscreen_languagetslver((srenpy/parser.pytscreen_statement s      ttestcasecCs|j|j}|jd|j|jdtjjj|j|}|j t j |||}|j st j ||gd|j}n|S(NRstestcase statementi(RRRRR;ttestt testparserR!RRRtTestcaseRRiR(RRfRRR7((srenpy/parser.pyttestcase_statement s     "c s|jd|j|jd|jg}d}d}fd}x(jr{jdr|dk rjdnj}y|j }WqxjdqxXqTjdrk|dkrjdnj}y|j }WnjdnX|j t j j |||||d}d}d}d}qTjd qTW|rjd n|j|jr|St j|||jS( NRstranslate strings statementcs_|j}y5t|ddtjjd}t|tjjSWnjdnXdS(Nstevaliscould not parse string( RRR;Rtnew_compile_flagsRRlt__dict__R(Rltbc(R(srenpy/parser.pyt parse_string s tolds(previous string is missing a translationsCould not parse string.tnewsno string to translatesunknown statements%final string is missing a translation(RRRRRRRRRRoRWR;RtTranslateStringRRiR( tinit_loctlanguageRRvRRfRtnewlocR((Rsrenpy/parser.pyttranslate_strings sJ         %   t translatecCsn|j|j}|dkr'd}n|j|j}|dkrUt|||S|dkrz>|j}t|_t||g}tj |||gSWd||_XnZ|dkr z>|j}t|_t ||g}tj |||gSWd||_Xn|jd|j |j dt|j}|jtj||||tj|gS(NRtstringsRtstyleRstranslate statement(RRRRRRR]RyRtTranslateEarlyBlocktstyle_statementtTranslateBlockRRR!RRt Translatet EndTranslate(RRfRt identifierR~Rv((srenpy/parser.pyttranslate_statement s4               Rcs|j|j}dtj||fd}x||rNq?W|jdsx|jd|jnS|jd|j|j }x-|j rx||rqW|jqW|j stj |g|j n|j S(Ncs|jdrDdk r+|jdn|j|j_tS|jdr`t_tS|jdrjdk r|jdn|j|j _tS|jdr|j|j }|t j j kr|jd|nj j|tS|jdrIjdk r0|jd n|j|j_tS|j }|dk r|d kr|t j j kr|jd|n|jkr|jd |n|j|jj|RBRERJRLRNRPRRRURZR`RbRdRfRgRjRoRqRsRvRyRzR|R}RRRRRtenvirontgetRRRRRRRRRRR!RARR(((srenpy/parser.pyts        7     G   /Z)  I  w K 5$  +  &  ""  !   D-Z0 1  #