home *** CD-ROM | disk | FTP | other *** search
/ ftp.cs.arizona.edu / ftp.cs.arizona.edu.tar / ftp.cs.arizona.edu / icon / historic / v92.tgz / v92.tar / v92 / src / runtime / keyword.r < prev    next >
Text File  |  1996-03-22  |  18KB  |  749 lines
  1. /*
  2.  * File: keyword.r
  3.  *  Contents: all keywords
  4.  *
  5.  *  After adding keywords, be sure to rerun ../icont/mkkwd.
  6.  */
  7.  
  8. #define KDef(p,n) int Cat(K,p) Params((dptr cargp));
  9. #include "::h:kdefs.h"
  10. #undef KDef
  11.  
  12. "&allocated - the space used in the storage regions:"
  13. " total, static, string, and block"
  14. keyword{4} allocated
  15.    abstract {
  16.       return integer
  17.       }
  18.    inline {
  19.       suspend C_integer stattotal + strtotal + blktotal;
  20.       suspend C_integer stattotal;
  21.       suspend C_integer strtotal;
  22.       return  C_integer blktotal;
  23.       }
  24. end
  25.  
  26. "&clock - a string consisting of the current time of day"
  27. keyword{1} clock
  28.    abstract {
  29.       return string
  30.       }
  31.    inline {
  32.       struct cal_time ct;
  33.       char sbuf[9], *tmp;
  34.  
  35.       getitime(&ct);
  36.       sprintf(sbuf,"%02d:%02d:%02d", ct.hour, ct.minute, ct.second);
  37.       Protect(tmp = alcstr(sbuf,(word)8), runerr(0));
  38.       return string(8, tmp);
  39.       }
  40. end
  41.  
  42. "&collections - the number of collections: total, triggered by static requests"
  43. " triggered by string requests, and triggered by block requests"
  44. keyword{4} collections
  45.    abstract {
  46.       return integer
  47.       }
  48.    inline {
  49.       suspend C_integer coll_tot;
  50.       suspend C_integer coll_stat;
  51.       suspend C_integer coll_str;
  52.       return  C_integer coll_blk;
  53.       }
  54. end
  55.  
  56. #if !COMPILER
  57. "&column - source column number of current execution point"
  58. keyword{1} column
  59.    abstract {
  60.       return integer;
  61.       }
  62.    inline {
  63. #ifdef MultiThread
  64. #ifdef EventMon
  65.       return C_integer findcol(ipc.opnd);
  66. #else                    /* EventMon */
  67.       fail;
  68. #endif                    /* EventMon */
  69. #else
  70.       fail;
  71. #endif                    /* MultiThread */
  72.       }
  73. end
  74. #endif                    /* !COMPILER */
  75.  
  76. "¤t - the currently active co-expression"
  77. keyword{1} current
  78.    abstract {
  79.       return coexpr
  80.       }
  81.    inline {
  82.       return k_current;
  83.       }
  84. end
  85.  
  86. "&date - the current date"
  87. keyword{1} date
  88.    abstract {
  89.       return string
  90.       }
  91.    inline {
  92.       struct cal_time ct;
  93.       char sbuf[11], *tmp;
  94.  
  95.       getitime(&ct);
  96.       sprintf(sbuf, "%04d/%02d/%02d", ct.year, ct.month_no, ct.mday);
  97.       Protect(tmp = alcstr(sbuf,(word)10), runerr(0));
  98.       return string(10, tmp);
  99.       }
  100. end
  101.  
  102. "&dateline - current date and time"
  103. keyword{1} dateline
  104.    abstract {
  105.       return string
  106.       }
  107.    body {
  108.       struct cal_time ct;
  109.       char sbuf[MaxCvtLen];
  110.       int hour;
  111.       char *merid, *tmp;
  112.       int i;
  113.  
  114.       getitime(&ct);
  115.       if ((hour = ct.hour) >= 12) {
  116.          merid = "pm";
  117.          if (hour > 12)
  118.             hour -= 12;
  119.          }
  120.       else {
  121.          merid = "am";
  122.          if (hour < 1)
  123.             hour += 12;
  124.          }
  125.       sprintf(sbuf, "%s, %s %d, %d  %d:%02d %s", ct.wday, ct.month_nm,
  126.          ct.mday, ct.year, hour, ct.minute, merid);
  127.        i = strlen(sbuf);
  128.        Protect(tmp = alcstr(sbuf, i), runerr(0));
  129.        return string(i, tmp);
  130.        }
  131. end
  132.  
  133. "&digits - a cset consisting of the 10 decimal digits"
  134. keyword{1} digits
  135.    constant '0123456789'
  136. end
  137.  
  138. "&e - the base of the natural logarithms"
  139. keyword{1} e
  140.    constant 2.71828182845904523536028747135266249775724709369996
  141. end
  142.  
  143. "&error - enable/disable error conversion"
  144. keyword{1} error
  145.    abstract {
  146.       return kywdint
  147.       }
  148.    inline {
  149.       return kywdint(&kywd_err);
  150.       }
  151. end
  152.  
  153. "&errornumber - error number of last error converted to failure"
  154. keyword{0,1} errornumber
  155.    abstract {
  156.       return integer
  157.       }
  158.    inline {
  159.       if (k_errornumber == 0)
  160.          fail;
  161.       return C_integer k_errornumber;
  162.       }
  163. end
  164.  
  165. "&errortext - error message of last error converted to failure"
  166. keyword{0,1} errortext
  167.    abstract {
  168.       return string
  169.       }
  170.    inline {
  171.       if (k_errornumber == 0)
  172.          fail;
  173.       return C_string k_errortext;
  174.       }
  175. end
  176.  
  177. "&errorvalue - erroneous value of last error converted to failure"
  178. keyword{0,1} errorvalue
  179.    abstract {
  180.       return any_value
  181.       }
  182.    inline {
  183.       if (have_errval)
  184.          return k_errorvalue;
  185.       else
  186.          fail;
  187.       }
  188. end
  189.  
  190. "&errout - standard error output."
  191. keyword{1} errout
  192.     abstract {
  193.        return file
  194.        }
  195.     inline {
  196.        return file(&k_errout);
  197.        }
  198. end
  199.  
  200. "&fail - just fail"
  201. keyword{0} fail
  202.    abstract {
  203.       return empty_type
  204.       }
  205.    inline {
  206.       fail;
  207.       }
  208. end
  209.  
  210. "&eventcode - event in monitored program"
  211. keyword{0,1} eventcode
  212.    abstract {
  213.       return kywdevent
  214.       }
  215.    inline {
  216.       return kywdevent(&k_eventcode);
  217.       }
  218. end
  219.  
  220. "&eventsource - source of events in monitoring program"
  221. keyword{0,1} eventsource
  222.    abstract {
  223.       return kywdevent
  224.       }
  225.    inline {
  226.       return kywdevent(&k_eventsource);
  227.       }
  228. end
  229.  
  230. "&eventvalue - value from event in monitored program"
  231. keyword{0,1} eventvalue
  232.    abstract {
  233.       return kywdevent
  234.       }
  235.    inline {
  236.       return kywdevent(&k_eventvalue);
  237.       }
  238. end
  239.  
  240. "&features - generate strings identifying features in this version of Icon"
  241. keyword{1,*} features
  242.    abstract {
  243.       return string
  244.       }
  245.    body {
  246. #if COMPILER
  247. #define Feature(guard,sym,kwval) if ((guard) && (kwval)) suspend C_string kwval;
  248. #else                    /* COMPILER */
  249. #define Feature(guard,sym,kwval) if (kwval) suspend C_string kwval;
  250. #endif                    /* COMPILER */
  251. #include "::h:features.h"
  252.       fail;
  253.       }
  254. end
  255.  
  256. "&file - name of the source file for the current execution point"
  257. keyword{1} file
  258.    abstract {
  259.       return string
  260.       }
  261.    inline {
  262. #if COMPILER
  263.       if (line_info)
  264.          return C_string file_name;
  265.       else
  266.          runerr(402);
  267. #else                    /* COMPILER */
  268.       char *s;
  269.       s = findfile(ipc.opnd);
  270.       if (!strcmp(s,"?")) fail;
  271.       return C_string s;
  272. #endif                    /* COMPILER */
  273.       }
  274. end
  275.  
  276. "&host - a string that identifies the host computer Icon is running on."
  277. keyword{1} host
  278.    abstract {
  279.      return string
  280.      }
  281.    inline {
  282.       char sbuf[MaxCvtLen], *tmp;
  283.       int i;
  284.  
  285.       iconhost(sbuf);
  286.       i = strlen(sbuf);
  287.       Protect(tmp = alcstr(sbuf, i), runerr(0));
  288.       return string(i, tmp);
  289.       }
  290. end
  291.  
  292. "&input - the standard input file"
  293. keyword{1} input
  294.    abstract {
  295.       return file
  296.       }
  297.    inline {
  298.       return file(&k_input);
  299.       }
  300. end
  301.  
  302. "&lcase - a cset consisting of the 26 lower case letters"
  303. keyword{1} lcase
  304.    constant 'abcdefghijklmnopqrstuvwxyz'
  305. end
  306.  
  307. "&letters - a cset consisting of the 52 letters"
  308. keyword{1} letters
  309.    constant 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'
  310. end
  311.  
  312. "&level - level of procedure call."
  313. keyword{1} level
  314.    abstract {
  315.       return integer
  316.       }
  317.  
  318.    inline {
  319. #if COMPILER
  320.       if (!debug_info)
  321.          runerr(402);
  322. #endif                    /* COMPILER */
  323.       return C_integer k_level;
  324.       }
  325. end
  326.  
  327. "&line - source line number of current execution point"
  328. keyword{1} line
  329.    abstract {
  330.       return integer;
  331.       }
  332.    inline {
  333. #if COMPILER
  334.       if (line_info)
  335.          return C_integer line_num;
  336.       else
  337.          runerr(402);
  338. #else                    /* COMPILER */
  339.       return C_integer findline(ipc.opnd);
  340. #endif                    /* COMPILER */
  341.       }
  342. end
  343.  
  344. "&main - the main co-expression."
  345. keyword{1} main
  346.    abstract {
  347.       return coexpr
  348.       }
  349.    inline {
  350.       return k_main;
  351.       }
  352. end
  353.  
  354. "&null - the null value."
  355. keyword{1} null
  356.    abstract {
  357.       return null
  358.       }
  359.    inline {
  360.       return nulldesc;
  361.       }
  362. end
  363.  
  364. "&output - the standard output file."
  365. keyword{1} output
  366.    abstract {
  367.       return file
  368.       }
  369.    inline {
  370.       return file(&k_output);
  371.       }
  372. end
  373.  
  374. "&phi - the golden ratio"
  375. keyword{1} phi
  376.    constant 1.618033988749894848204586834365638117720309180
  377. end
  378.  
  379. "&pi - the ratio of circumference to diameter"
  380. keyword{1} pi
  381.    constant 3.14159265358979323846264338327950288419716939937511
  382. end
  383.  
  384. "&pos - a variable containing the current focus in string scanning."
  385. keyword{1} pos
  386.    abstract {
  387.       return kywdpos
  388.       }
  389.     inline {
  390.       return kywdpos(&kywd_pos);
  391.       }
  392. end
  393.  
  394. "&progname - a variable containing the program name."
  395. keyword{1} progname
  396.    abstract {
  397.       return kywdstr
  398.       }
  399.     inline {
  400.       return kywdstr(&kywd_prog);
  401.       }
  402. end
  403.  
  404. "&random - a variable containing the current seed for random operations."
  405. keyword{1} random
  406.    abstract {
  407.       return kywdint
  408.       }
  409.    inline {
  410.       return kywdint(&kywd_ran);
  411.       }
  412. end
  413.  
  414. "®ions - generates regions sizes"
  415. keyword{3} regions
  416.    abstract {
  417.       return integer
  418.       }
  419.    inline {
  420.       word allRegions = 0;
  421.       struct region *rp;
  422.  
  423.       suspend C_integer 0;        /* static region */
  424.  
  425.       allRegions = DiffPtrs(strend,strbase);
  426.       for (rp = curstring->next; rp; rp = rp->next)
  427.      allRegions += DiffPtrs(rp->end,rp->base);
  428.       for (rp = curstring->prev; rp; rp = rp->prev)
  429.      allRegions += DiffPtrs(rp->end,rp->base);
  430.       suspend C_integer allRegions;    /* string region */
  431.  
  432.       allRegions = DiffPtrs(blkend,blkbase);
  433.       for (rp = curblock->next; rp; rp = rp->next)
  434.      allRegions += DiffPtrs(rp->end,rp->base);
  435.       for (rp = curblock->prev; rp; rp = rp->prev)
  436.      allRegions += DiffPtrs(rp->end,rp->base);
  437.       return C_integer allRegions;    /* block region */
  438.       }
  439. end
  440.  
  441. "&source - the co-expression that invoked the current co-expression."
  442. keyword{1} source
  443.    abstract {
  444.        return coexpr
  445.        }
  446.    inline {
  447. #ifndef Coexpr
  448.          return k_main;
  449. #else                    /* Coexpr */
  450.          return coexpr(topact((struct b_coexpr *)BlkLoc(k_current)));
  451. #endif                    /* Coexpr */
  452.          }
  453. end
  454.  
  455. "&storage - generate the amount of storage used for each region."
  456. keyword{3} storage
  457.    abstract {
  458.       return integer
  459.       }
  460.    inline {
  461.       word allRegions = 0;
  462.       struct region *rp;
  463.  
  464.       suspend C_integer 0;        /* static region */
  465.  
  466.       allRegions = DiffPtrs(strfree,strbase);
  467.       for (rp = curstring->next; rp; rp = rp->next)
  468.      allRegions += DiffPtrs(rp->free,rp->base);
  469.       for (rp = curstring->prev; rp; rp = rp->prev)
  470.      allRegions += DiffPtrs(rp->free,rp->base);
  471.       suspend C_integer allRegions;    /* string region */
  472.  
  473.       allRegions = DiffPtrs(blkfree,blkbase);
  474.       for (rp = curblock->next; rp; rp = rp->next)
  475.      allRegions += DiffPtrs(rp->free,rp->base);
  476.       for (rp = curblock->prev; rp; rp = rp->prev)
  477.      allRegions += DiffPtrs(rp->free,rp->base);
  478.       return C_integer allRegions;    /* block region */
  479.       }
  480. end
  481.  
  482. "&subject - variable containing the current subject of string scanning."
  483. keyword{1} subject
  484.    abstract {
  485.       return kywdsubj
  486.       }
  487.    inline {
  488.       return kywdsubj(&k_subject);
  489.       }
  490. end
  491.  
  492. "&time - the elapsed execution time in milliseconds."
  493. keyword{1} time
  494.    abstract {
  495.       return integer
  496.       }
  497.    inline {
  498.       return C_integer millisec();
  499.       }
  500. end
  501.  
  502. "&trace - variable that controls procedure tracing."
  503. keyword{1} trace
  504.    abstract {
  505.       return kywdint
  506.       }
  507.    inline {
  508.       return kywdint(&kywd_trc);
  509.       }
  510. end
  511.  
  512. "&dump - variable that controls termination dump."
  513. keyword{1} dump
  514.    abstract {
  515.       return kywdint
  516.       }
  517.    inline {
  518.       return kywdint(&kywd_dmp);
  519.       }
  520. end
  521.  
  522. "&ucase - a cset consisting of the 26 uppercase characters."
  523. keyword{1} ucase
  524.    constant 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
  525. end
  526.  
  527. "&version - a string indentifying this version of Icon."
  528. keyword{1} version
  529.    constant Version
  530. end
  531.  
  532. #ifndef MultiThread
  533. struct descrip kywd_xwin[2] = {{D_Null}};
  534. #endif                    /* MultiThread */
  535.  
  536. "&window - variable containing the current graphics rendering context."
  537. #ifdef Graphics
  538. keyword{1} window
  539.    abstract {
  540.       return kywdwin
  541.       }
  542.    inline {
  543.       return kywdwin(kywd_xwin + XKey_Window);
  544.       }
  545. end
  546. #else                    /* Graphics */
  547. keyword{0} window
  548.    abstract {
  549.       return empty_type
  550.       }
  551.    inline {
  552.       fail;
  553.       }
  554. end
  555. #endif                    /* Graphics */
  556.  
  557. #ifdef Graphics
  558. "&col - mouse horizontal position in text columns."
  559. keyword{1} col
  560.    abstract { return kywdint }
  561.    inline { if (is:null(lastEventWin)) runerr(140, lastEventWin);
  562.         else return kywdint(&erCol); }
  563. end
  564.  
  565. "&row - mouse vertical position in text rows."
  566. keyword{1} row
  567.    abstract { return kywdint }
  568.    inline { if (is:null(lastEventWin)) runerr(140, lastEventWin);
  569.         else return kywdint(&erRow); }
  570. end
  571.  
  572. "&x - mouse horizontal position."
  573. keyword{1} x
  574.    abstract { return kywdint }
  575.    inline { if (is:null(lastEventWin)) runerr(140, lastEventWin);
  576.         else return kywdint(&erX); }
  577. end
  578.  
  579. "&y - mouse vertical position."
  580. keyword{1} y
  581.    abstract { return kywdint }
  582.    inline { if (is:null(lastEventWin)) runerr(140, lastEventWin);
  583.         else return kywdint(&erY); }
  584. end
  585.  
  586. "&interval - milliseconds since previous event."
  587. keyword{1} interval
  588.    abstract { return kywdint }
  589.    inline { if (is:null(lastEventWin)) runerr(140, lastEventWin);
  590.         else return kywdint(&erInterval); }
  591. end
  592.  
  593. "&control - null if control key was down on last X event, else failure"
  594. keyword{0,1} control
  595.    abstract { return null }
  596.    inline { if (is:null(lastEventWin)) runerr(140, lastEventWin);
  597.         else if (xmod_control) return nulldesc; else fail; }
  598. end
  599.  
  600. "&shift - null if shift key was down on last X event, else failure"
  601. keyword{0,1} shift
  602.    abstract { return null }
  603.    inline { if (is:null(lastEventWin)) runerr(140, lastEventWin);
  604.         else if (xmod_shift) return nulldesc; else fail; }
  605. end
  606.  
  607. "&meta - null if meta key was down on last X event, else failure"
  608. keyword{0,1} meta
  609.    abstract { return null }
  610.    inline { if (is:null(lastEventWin)) runerr(140, lastEventWin);
  611.         else if (xmod_meta) return nulldesc; else fail; }
  612. end
  613. #else                    /* Graphics */
  614. "&col - mouse horizontal position in text columns."
  615. keyword{0} col
  616.    abstract { return empty_type }
  617.    inline { fail; }
  618. end
  619.  
  620. "&row - mouse vertical position in text rows."
  621. keyword{0} row
  622.    abstract { return empty_type }
  623.    inline { fail; }
  624. end
  625.  
  626. "&x - mouse horizontal position."
  627. keyword{0} x
  628.    abstract { return empty_type }
  629.    inline { fail; }
  630. end
  631.  
  632. "&y - mouse vertical position."
  633. keyword{0} y
  634.    abstract { return empty_type }
  635.    inline { fail; }
  636. end
  637.  
  638. "&interval - milliseconds since previous event."
  639. keyword{0} interval
  640.    abstract { return empty_type }
  641.    inline { fail; }
  642. end
  643.  
  644. "&control - null if control key was down on last X event, else failure"
  645. keyword{0} control
  646.    abstract { return empty_type}
  647.    inline { fail; }
  648. end
  649.  
  650. "&shift - null if shift key was down on last X event, else failure"
  651. keyword{0} shift
  652.    abstract { return empty_type }
  653.    inline { fail; }
  654. end
  655.  
  656. "&meta - null if meta key was down on last X event, else failure"
  657. keyword{0} meta
  658.    abstract { return empty_type }
  659.    inline { fail; }
  660. end
  661. #endif                    /* Graphics */
  662.  
  663. "&lpress - left button press."
  664. keyword{1} lpress
  665.    abstract { return integer} inline { return C_integer MOUSELEFT; }
  666. end
  667. "&mpress - middle button press."
  668. keyword{1} mpress
  669.    abstract { return integer} inline { return C_integer MOUSEMID; }
  670. end
  671. "&rpress - right button press."
  672. keyword{1} rpress
  673.    abstract { return integer} inline { return C_integer MOUSERIGHT; }
  674. end
  675. "&lrelease - left button release."
  676. keyword{1} lrelease
  677.    abstract { return integer} inline { return C_integer MOUSELEFTUP; }
  678. end
  679. "&mrelease - middle button release."
  680. keyword{1} mrelease
  681.    abstract { return integer} inline { return C_integer MOUSEMIDUP; }
  682. end
  683. "&rrelease - right button release."
  684. keyword{1} rrelease
  685.    abstract { return integer} inline { return C_integer MOUSERIGHTUP; }
  686. end
  687. "&ldrag - left button drag."
  688. keyword{1} ldrag
  689.    abstract { return integer} inline { return C_integer MOUSELEFTDRAG; }
  690. end
  691. "&mdrag - middle button drag."
  692. keyword{1} mdrag
  693.    abstract { return integer} inline { return C_integer MOUSEMIDDRAG; }
  694. end
  695. "&rdrag - right button drag."
  696. keyword{1} rdrag
  697.    abstract { return integer} inline { return C_integer MOUSERIGHTDRAG; }
  698. end
  699. "&resize - window resize."
  700. keyword{1} resize
  701.    abstract { return integer} inline { return C_integer RESIZED; }
  702. end
  703.  
  704. "&ascii - a cset consisting of the 128 ascii characters"
  705. keyword{1} ascii
  706. #if EBCDIC == 1
  707. constant '\
  708. \x00\x01\x02\x03\x05\x07\x0b\x0c\x0d\x0e\x0f\x10\x11\x12\x13\x16\
  709. \x18\x19\x1c\x1d\x1e\x1f\x25\x26\x27\x2d\x2e\x2f\x32\x37\x3c\x3d\
  710. \x3f\x40\x4b\x4c\x4d\x4e\x4f\x50\x5a\x5b\x5c\x5d\x5e\x5f\x60\x61\
  711. \x6b\x6c\x6d\x6e\x6f\x79\x7a\x7b\x7c\x7d\x7e\x7f\x81\x82\x83\x84\
  712. \x85\x86\x87\x88\x89\x91\x92\x93\x94\x95\x96\x97\x98\x99\xa1\xa2\
  713. \xa3\xa4\xa5\xa6\xa7\xa8\xa9\xad\xbd\xc0\xc1\xc2\xc3\xc4\xc5\xc6\
  714. \xc7\xc8\xc9\xd0\xd1\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xe0\xe2\xe3\
  715. \xe4\xe5\xe6\xe7\xe8\xe9\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9'
  716. #else                    /* EBCDIC == 1 */
  717. constant '\
  718. \000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\
  719. \020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037\
  720. \040\041\042\043\044\045\046\047\050\051\052\053\054\055\056\057\
  721. \060\061\062\063\064\065\066\067\070\071\072\073\074\075\076\077\
  722. \100\101\102\103\104\105\106\107\110\111\112\113\114\115\116\117\
  723. \120\121\122\123\124\125\126\127\130\131\132\133\134\135\136\137\
  724. \140\141\142\143\144\145\146\147\150\151\152\153\154\155\156\157\
  725. \160\161\162\163\164\165\166\167\170\171\172\173\174\175\176\177'
  726. #endif                    /* EBCDIC == 1 */
  727. end
  728.  
  729. "&cset - a cset consisting of all the 256 characters."
  730. keyword{1} cset
  731. constant '\
  732. \0\1\2\3\4\5\6\7\10\11\12\13\14\15\16\17\
  733. \20\21\22\23\24\25\26\27\30\31\32\33\34\35\36\37\
  734. \40\41\42\43\44\45\46\47\50\51\52\53\54\55\56\57\
  735. \60\61\62\63\64\65\66\67\70\71\72\73\74\75\76\77\
  736. \100\101\102\103\104\105\106\107\110\111\112\113\114\115\116\117\
  737. \120\121\122\123\124\125\126\127\130\131\132\133\134\135\136\137\
  738. \140\141\142\143\144\145\146\147\150\151\152\153\154\155\156\157\
  739. \160\161\162\163\164\165\166\167\170\171\172\173\174\175\176\177\
  740. \200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217\
  741. \220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\
  742. \240\241\242\243\244\245\246\247\250\251\252\253\254\255\256\257\
  743. \260\261\262\263\264\265\266\267\270\271\272\273\274\275\276\277\
  744. \300\301\302\303\304\305\306\307\310\311\312\313\314\315\316\317\
  745. \320\321\322\323\324\325\326\327\330\331\332\333\334\335\336\337\
  746. \340\341\342\343\344\345\346\347\350\351\352\353\354\355\356\357\
  747. \360\361\362\363\364\365\366\367\370\371\372\373\374\375\376\377'
  748. end
  749.