API tools faq
paste
Advertisement
snake5

SGScript - sgs2c v0.5

snake5
Mar 1st, 2014
277
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 14.09 KB | None | 0 0
raw download clone embed print report
  1. #include <sgscript.h>
  2.  
  3. static int Fsgs__fmt_bytenum( SGS_CTX, sgs_VarObj* obj )
  4. {
  5.     int ret = 0;
  6.     SGSFN( "fmt_bytenum" );
  7.     sgs_Variable T[ 9 ];
  8.     sgs_Variable* CN = (sgs_Variable*) obj->data;
  9.     sgs_PushItem( C, 0 );
  10.     sgs_StoreVariable( C, T+0 );
  11.     { int i; for( i = 1; i < 9; ++i )
  12.         T[ i ].type = SGS_VT_NULL; }
  13.     // set
  14.     sgs_Assign( C, T+1, T+0 );
  15.     // set
  16.     sgs_Assign( C, T+2, CN+0 );
  17.     // push
  18.     sgs_PushVariable( C, CN+1 );
  19.     // push
  20.     sgs_PushVariable( C, CN+2 );
  21.     // push
  22.     sgs_PushVariable( C, CN+3 );
  23.     // array
  24.     sgs_Release( C, T+3 );
  25.     sgs_InitArray( C, T+3, 3 );
  26.     _op6:;
  27.     // gt
  28.     { int V = (sgs_Compare( C, T+0, CN+4 ) > 0);
  29.     sgs_Release( C, T+5 ); sgs_InitBool( T+5, V ); }
  30.     // jump_if_true
  31.     if( sgs_GetBoolP( C, T+5 ) ) goto _op10;
  32.     // set
  33.     sgs_Assign( C, T+4, T+5 );
  34.     // jump
  35.     goto _op15;
  36.     _op10:;
  37.     // getprop
  38.     sgs_Release( C, T+8 );
  39.     sgs_GetIndexPPP( C, T+3, CN+5, T+8, 1 );
  40.     // sub
  41.     sgs_ArithOp( C, T+7, T+8, CN+6, SGS_EOP_SUB );
  42.     // lt
  43.     { int V = (sgs_Compare( C, T+2, T+7 ) < 0);
  44.     sgs_Release( C, T+6 ); sgs_InitBool( T+6, V ); }
  45.     // set
  46.     sgs_Assign( C, T+4, T+6 );
  47.     // nop
  48.     _op15:;
  49.     // jump_if_false
  50.     if( !sgs_GetBoolP( C, T+4 ) ) goto _op20;
  51.     // div
  52.     sgs_ArithOp( C, T+4, T+0, CN+7, SGS_EOP_DIV );
  53.     // set
  54.     sgs_Assign( C, T+0, T+4 );
  55.     // inc
  56.     sgs_IncDec( C, T+2, T+2, 1 );
  57.     // jump
  58.     goto _op6;
  59.     _op20:;
  60.     // push
  61.     sgs_PushVariable( C, T+0 );
  62.     // push
  63.     sgs_PushVariable( C, CN+8 );
  64.     // getindex
  65.     sgs_Release( C, T+5 );
  66.     sgs_GetIndexPPP( C, T+3, T+2, T+5, 0 );
  67.     // push
  68.     sgs_PushVariable( C, T+5 );
  69.     // push
  70.     sgs_PushVariable( C, CN+9 );
  71.     // push
  72.     sgs_PushVariable( C, T+1 );
  73.     // push
  74.     sgs_PushVariable( C, CN+10 );
  75.     // mconcat
  76.     sgs_Release( C, T+4 );
  77.     sgs_StringConcat( C, 6 );
  78.     sgs_StoreVariable( C, T+4 );
  79.     // push
  80.     sgs_PushVariable( C, T+4 );
  81.     // return
  82.     ret = 1;
  83.     goto _ret;
  84.     // ---
  85.     _ret:
  86.     sgs_ReleaseArray( C, T, 9 );
  87.     return ret;
  88. }
  89.  
  90. static int Dsgs__fmt_bytenum( SGS_CTX, sgs_VarObj* obj )
  91. {
  92.     sgs_ReleaseArray( C, (sgs_Variable*) obj->data, 11 );
  93. }
  94.  
  95. static int Gsgs__fmt_bytenum( SGS_CTX, sgs_VarObj* obj )
  96. {
  97.     sgs_GCMarkArray( C, (sgs_Variable*) obj->data, 11 );
  98. }
  99.  
  100. static sgs_ObjInterface Tsgs__fmt_bytenum[1] =
  101. {{
  102.     "func",
  103.     Dsgs__fmt_bytenum, Gsgs__fmt_bytenum,
  104.     NULL, NULL,
  105.     NULL, NULL, NULL, NULL,
  106.     Fsgs__fmt_bytenum, NULL
  107. }};
  108.  
  109. static int Isgs__fmt_bytenum( SGS_CTX, sgs_Variable* out )
  110. {
  111.     sgs_Variable* CN = (sgs_Variable*)
  112.         sgs_InitObjectIPA( C, out, sizeof(sgs_Variable) * 11, Tsgs__fmt_bytenum );
  113.     sgs_InitInt( CN+0, 0LL );
  114.     sgs_InitStringBuf( C, CN+1, "B", 1 );
  115.     sgs_InitStringBuf( C, CN+2, "kB", 2 );
  116.     sgs_InitStringBuf( C, CN+3, "MB", 2 );
  117.     sgs_InitInt( CN+4, 2048LL );
  118.     sgs_InitStringBuf( C, CN+5, "size", 4 );
  119.     sgs_InitInt( CN+6, 1LL );
  120.     sgs_InitInt( CN+7, 1024LL );
  121.     sgs_InitStringBuf( C, CN+8, " ", 1 );
  122.     sgs_InitStringBuf( C, CN+9, " (", 2 );
  123.     sgs_InitStringBuf( C, CN+10, " bytes)", 7 );
  124. }
  125.  
  126. int sgscript_main( SGS_CTX )
  127. {
  128.     int ret = 0;
  129.     SGSFN( "<main>" );
  130.     sgs_Variable T[ 32 ];
  131.     sgs_Variable CN[ 27 ];
  132.     { int i; for( i = 0; i < 32; ++i )
  133.         T[ i ].type = SGS_VT_NULL; }
  134.     Isgs__fmt_bytenum( C, CN+0 );
  135.     sgs_InitStringBuf( C, CN+1, "fmt_bytenum", 11 );
  136.     sgs_InitInt( CN+2, 100000LL );
  137.     sgs_InitStringBuf( C, CN+3, "sys_stat", 8 );
  138.     sgs_InitInt( CN+4, 3LL );
  139.     sgs_InitInt( CN+5, 6LL );
  140.     sgs_InitStringBuf( C, CN+6, "map", 3 );
  141.     sgs_InitStringBuf( C, CN+7, "ftime", 5 );
  142.     sgs_InitInt( CN+8, 0LL );
  143.     sgs_InitStringBuf( C, CN+9, "unset", 5 );
  144.     sgs_InitNull( CN+10 );
  145.     sgs_InitStringBuf( C, CN+11, "printlns", 8 );
  146.     sgs_InitStringBuf( C, CN+12, "-- info --", 10 );
  147.     sgs_InitStringBuf( C, CN+13, "count: ", 7 );
  148.     sgs_InitStringBuf( C, CN+14, "-- time --", 10 );
  149.     sgs_InitStringBuf( C, CN+15, "set: ", 5 );
  150.     sgs_InitStringBuf( C, CN+16, "get: ", 5 );
  151.     sgs_InitStringBuf( C, CN+17, "unset: ", 7 );
  152.     sgs_InitStringBuf( C, CN+18, "-- memory --", 12 );
  153.     sgs_InitStringBuf( C, CN+19, "before: ", 8 );
  154.     sgs_InitStringBuf( C, CN+20, "load: ", 6 );
  155.     sgs_InitStringBuf( C, CN+21, "unload: ", 8 );
  156.     sgs_InitStringBuf( C, CN+22, "memory after dict free: ", 24 );
  157.     sgs_InitStringBuf( C, CN+23, "delta: ", 7 );
  158.     sgs_InitStringBuf( C, CN+24, "junk memory after unset: ", 25 );
  159.     sgs_InitStringBuf( C, CN+25, "accumulated overhead: ", 22 );
  160.     sgs_InitStringBuf( C, CN+26, "-- allocation count --", 22 );
  161.     // setvar
  162.     sgs_SetGlobalPP( C, CN+1, CN+0 );
  163.     // set
  164.     sgs_Assign( C, T+0, CN+2 );
  165.     // getvar
  166.     sgs_Release( C, T+16 );
  167.     sgs_GetGlobalPP( C, CN+3, T+16 );
  168.     // set
  169.     sgs_Assign( C, T+15, CN+4 );
  170.     // call
  171.     sgs_PushVariable( C, T+15 );
  172.     sgs_FCallP( C, T+16, 1, 1, 0 );
  173.     sgs_Release( C, T+15 );
  174.     sgs_StoreVariable( C, T+15 );
  175.     // set
  176.     sgs_Assign( C, T+1, T+15 );
  177.     // getvar
  178.     sgs_Release( C, T+16 );
  179.     sgs_GetGlobalPP( C, CN+3, T+16 );
  180.     // set
  181.     sgs_Assign( C, T+15, CN+5 );
  182.     // call
  183.     sgs_PushVariable( C, T+15 );
  184.     sgs_FCallP( C, T+16, 1, 1, 0 );
  185.     sgs_Release( C, T+15 );
  186.     sgs_StoreVariable( C, T+15 );
  187.     // set
  188.     sgs_Assign( C, T+2, T+15 );
  189.     // getvar
  190.     sgs_Release( C, T+15 );
  191.     sgs_GetGlobalPP( C, CN+6, T+15 );
  192.     // call
  193.     sgs_FCallP( C, T+15, 0, 1, 0 );
  194.     sgs_Release( C, T+15 );
  195.     sgs_StoreVariable( C, T+15 );
  196.     // set
  197.     sgs_Assign( C, T+3, T+15 );
  198.     // getvar
  199.     sgs_Release( C, T+15 );
  200.     sgs_GetGlobalPP( C, CN+7, T+15 );
  201.     // call
  202.     sgs_FCallP( C, T+15, 0, 1, 0 );
  203.     sgs_Release( C, T+15 );
  204.     sgs_StoreVariable( C, T+15 );
  205.     // set
  206.     sgs_Assign( C, T+4, T+15 );
  207.     // set
  208.     sgs_Assign( C, T+5, CN+8 );
  209.     _op17:;
  210.     // lt
  211.     { int V = (sgs_Compare( C, T+5, T+0 ) < 0);
  212.     sgs_Release( C, T+15 ); sgs_InitBool( T+15, V ); }
  213.     // jump_if_false
  214.     if( !sgs_GetBoolP( C, T+15 ) ) goto _op24;
  215.     // getvar
  216.     sgs_Release( C, T+15 );
  217.     sgs_GetGlobalPP( C, CN+7, T+15 );
  218.     // call
  219.     sgs_FCallP( C, T+15, 0, 1, 0 );
  220.     sgs_Release( C, T+15 );
  221.     sgs_StoreVariable( C, T+15 );
  222.     // setindex
  223.     sgs_SetIndexPPP( C, T+3, T+5, T+15, 0 );
  224.     // inc
  225.     sgs_IncDec( C, T+5, T+5, 1 );
  226.     // jump
  227.     goto _op17;
  228.     _op24:;
  229.     // getvar
  230.     sgs_Release( C, T+16 );
  231.     sgs_GetGlobalPP( C, CN+3, T+16 );
  232.     // set
  233.     sgs_Assign( C, T+15, CN+4 );
  234.     // call
  235.     sgs_PushVariable( C, T+15 );
  236.     sgs_FCallP( C, T+16, 1, 1, 0 );
  237.     sgs_Release( C, T+15 );
  238.     sgs_StoreVariable( C, T+15 );
  239.     // set
  240.     sgs_Assign( C, T+6, T+15 );
  241.     // getvar
  242.     sgs_Release( C, T+16 );
  243.     sgs_GetGlobalPP( C, CN+3, T+16 );
  244.     // set
  245.     sgs_Assign( C, T+15, CN+5 );
  246.     // call
  247.     sgs_PushVariable( C, T+15 );
  248.     sgs_FCallP( C, T+16, 1, 1, 0 );
  249.     sgs_Release( C, T+15 );
  250.     sgs_StoreVariable( C, T+15 );
  251.     // set
  252.     sgs_Assign( C, T+7, T+15 );
  253.     // getvar
  254.     sgs_Release( C, T+15 );
  255.     sgs_GetGlobalPP( C, CN+7, T+15 );
  256.     // call
  257.     sgs_FCallP( C, T+15, 0, 1, 0 );
  258.     sgs_Release( C, T+15 );
  259.     sgs_StoreVariable( C, T+15 );
  260.     // set
  261.     sgs_Assign( C, T+8, T+15 );
  262.     // set
  263.     sgs_Assign( C, T+5, CN+8 );
  264.     _op36:;
  265.     // lt
  266.     { int V = (sgs_Compare( C, T+5, T+0 ) < 0);
  267.     sgs_Release( C, T+15 ); sgs_InitBool( T+15, V ); }
  268.     // jump_if_false
  269.     if( !sgs_GetBoolP( C, T+15 ) ) goto _op41;
  270.     // getindex
  271.     sgs_Release( C, T+9 );
  272.     sgs_GetIndexPPP( C, T+3, T+5, T+9, 0 );
  273.     // inc
  274.     sgs_IncDec( C, T+5, T+5, 1 );
  275.     // jump
  276.     goto _op36;
  277.     _op41:;
  278.     // getvar
  279.     sgs_Release( C, T+15 );
  280.     sgs_GetGlobalPP( C, CN+7, T+15 );
  281.     // call
  282.     sgs_FCallP( C, T+15, 0, 1, 0 );
  283.     sgs_Release( C, T+15 );
  284.     sgs_StoreVariable( C, T+15 );
  285.     // set
  286.     sgs_Assign( C, T+10, T+15 );
  287.     // set
  288.     sgs_Assign( C, T+5, CN+8 );
  289.     _op45:;
  290.     // lt
  291.     { int V = (sgs_Compare( C, T+5, T+0 ) < 0);
  292.     sgs_Release( C, T+15 ); sgs_InitBool( T+15, V ); }
  293.     // jump_if_false
  294.     if( !sgs_GetBoolP( C, T+15 ) ) goto _op53;
  295.     // getvar
  296.     sgs_Release( C, T+17 );
  297.     sgs_GetGlobalPP( C, CN+9, T+17 );
  298.     // set
  299.     sgs_Assign( C, T+15, T+3 );
  300.     // set
  301.     sgs_Assign( C, T+16, T+5 );
  302.     // call
  303.     sgs_PushVariable( C, T+15 );
  304.     sgs_PushVariable( C, T+16 );
  305.     sgs_FCallP( C, T+17, 2, 0, 0 );
  306.     // inc
  307.     sgs_IncDec( C, T+5, T+5, 1 );
  308.     // jump
  309.     goto _op45;
  310.     _op53:;
  311.     // getvar
  312.     sgs_Release( C, T+16 );
  313.     sgs_GetGlobalPP( C, CN+3, T+16 );
  314.     // set
  315.     sgs_Assign( C, T+15, CN+4 );
  316.     // call
  317.     sgs_PushVariable( C, T+15 );
  318.     sgs_FCallP( C, T+16, 1, 1, 0 );
  319.     sgs_Release( C, T+15 );
  320.     sgs_StoreVariable( C, T+15 );
  321.     // set
  322.     sgs_Assign( C, T+11, T+15 );
  323.     // getvar
  324.     sgs_Release( C, T+16 );
  325.     sgs_GetGlobalPP( C, CN+3, T+16 );
  326.     // set
  327.     sgs_Assign( C, T+15, CN+5 );
  328.     // call
  329.     sgs_PushVariable( C, T+15 );
  330.     sgs_FCallP( C, T+16, 1, 1, 0 );
  331.     sgs_Release( C, T+15 );
  332.     sgs_StoreVariable( C, T+15 );
  333.     // set
  334.     sgs_Assign( C, T+12, T+15 );
  335.     // getvar
  336.     sgs_Release( C, T+15 );
  337.     sgs_GetGlobalPP( C, CN+7, T+15 );
  338.     // call
  339.     sgs_FCallP( C, T+15, 0, 1, 0 );
  340.     sgs_Release( C, T+15 );
  341.     sgs_StoreVariable( C, T+15 );
  342.     // set
  343.     sgs_Assign( C, T+13, T+15 );
  344.     // set
  345.     sgs_Assign( C, T+3, CN+10 );
  346.     // getvar
  347.     sgs_Release( C, T+16 );
  348.     sgs_GetGlobalPP( C, CN+3, T+16 );
  349.     // set
  350.     sgs_Assign( C, T+15, CN+4 );
  351.     // call
  352.     sgs_PushVariable( C, T+15 );
  353.     sgs_FCallP( C, T+16, 1, 1, 0 );
  354.     sgs_Release( C, T+15 );
  355.     sgs_StoreVariable( C, T+15 );
  356.     // set
  357.     sgs_Assign( C, T+14, T+15 );
  358.     // getvar
  359.     sgs_Release( C, T+17 );
  360.     sgs_GetGlobalPP( C, CN+11, T+17 );
  361.     // set
  362.     sgs_Assign( C, T+15, CN+12 );
  363.     // concat
  364.     sgs_PushVariable( C, CN+13 );
  365.     sgs_PushVariable( C, T+0 );
  366.     sgs_Release( C, T+16 );
  367.     sgs_StringConcat( C, 2 );
  368.     sgs_StoreVariable( C, T+16 );
  369.     // call
  370.     sgs_PushVariable( C, T+15 );
  371.     sgs_PushVariable( C, T+16 );
  372.     sgs_FCallP( C, T+17, 2, 0, 0 );
  373.     // getvar
  374.     sgs_Release( C, T+19 );
  375.     sgs_GetGlobalPP( C, CN+11, T+19 );
  376.     // set
  377.     sgs_Assign( C, T+15, CN+14 );
  378.     // sub
  379.     sgs_ArithOp( C, T+21, T+8, T+4, SGS_EOP_SUB );
  380.     // concat
  381.     sgs_PushVariable( C, CN+15 );
  382.     sgs_PushVariable( C, T+21 );
  383.     sgs_Release( C, T+16 );
  384.     sgs_StringConcat( C, 2 );
  385.     sgs_StoreVariable( C, T+16 );
  386.     // sub
  387.     sgs_ArithOp( C, T+21, T+10, T+8, SGS_EOP_SUB );
  388.     // concat
  389.     sgs_PushVariable( C, CN+16 );
  390.     sgs_PushVariable( C, T+21 );
  391.     sgs_Release( C, T+17 );
  392.     sgs_StringConcat( C, 2 );
  393.     sgs_StoreVariable( C, T+17 );
  394.     // sub
  395.     sgs_ArithOp( C, T+21, T+13, T+10, SGS_EOP_SUB );
  396.     // concat
  397.     sgs_PushVariable( C, CN+17 );
  398.     sgs_PushVariable( C, T+21 );
  399.     sgs_Release( C, T+18 );
  400.     sgs_StringConcat( C, 2 );
  401.     sgs_StoreVariable( C, T+18 );
  402.     // call
  403.     sgs_PushVariable( C, T+15 );
  404.     sgs_PushVariable( C, T+16 );
  405.     sgs_PushVariable( C, T+17 );
  406.     sgs_PushVariable( C, T+18 );
  407.     sgs_FCallP( C, T+19, 4, 0, 0 );
  408.     // getvar
  409.     sgs_Release( C, T+27 );
  410.     sgs_GetGlobalPP( C, CN+11, T+27 );
  411.     // set
  412.     sgs_Assign( C, T+15, CN+18 );
  413.     // getvar
  414.     sgs_Release( C, T+30 );
  415.     sgs_GetGlobalPP( C, CN+1, T+30 );
  416.     // set
  417.     sgs_Assign( C, T+29, T+1 );
  418.     // call
  419.     sgs_PushVariable( C, T+29 );
  420.     sgs_FCallP( C, T+30, 1, 1, 0 );
  421.     sgs_Release( C, T+29 );
  422.     sgs_StoreVariable( C, T+29 );
  423.     // concat
  424.     sgs_PushVariable( C, CN+19 );
  425.     sgs_PushVariable( C, T+29 );
  426.     sgs_Release( C, T+16 );
  427.     sgs_StringConcat( C, 2 );
  428.     sgs_StoreVariable( C, T+16 );
  429.     // getvar
  430.     sgs_Release( C, T+30 );
  431.     sgs_GetGlobalPP( C, CN+1, T+30 );
  432.     // set
  433.     sgs_Assign( C, T+29, T+6 );
  434.     // call
  435.     sgs_PushVariable( C, T+29 );
  436.     sgs_FCallP( C, T+30, 1, 1, 0 );
  437.     sgs_Release( C, T+29 );
  438.     sgs_StoreVariable( C, T+29 );
  439.     // concat
  440.     sgs_PushVariable( C, CN+20 );
  441.     sgs_PushVariable( C, T+29 );
  442.     sgs_Release( C, T+17 );
  443.     sgs_StringConcat( C, 2 );
  444.     sgs_StoreVariable( C, T+17 );
  445.     // getvar
  446.     sgs_Release( C, T+30 );
  447.     sgs_GetGlobalPP( C, CN+1, T+30 );
  448.     // set
  449.     sgs_Assign( C, T+29, T+11 );
  450.     // call
  451.     sgs_PushVariable( C, T+29 );
  452.     sgs_FCallP( C, T+30, 1, 1, 0 );
  453.     sgs_Release( C, T+29 );
  454.     sgs_StoreVariable( C, T+29 );
  455.     // concat
  456.     sgs_PushVariable( C, CN+21 );
  457.     sgs_PushVariable( C, T+29 );
  458.     sgs_Release( C, T+18 );
  459.     sgs_StringConcat( C, 2 );
  460.     sgs_StoreVariable( C, T+18 );
  461.     // getvar
  462.     sgs_Release( C, T+30 );
  463.     sgs_GetGlobalPP( C, CN+1, T+30 );
  464.     // set
  465.     sgs_Assign( C, T+29, T+14 );
  466.     // call
  467.     sgs_PushVariable( C, T+29 );
  468.     sgs_FCallP( C, T+30, 1, 1, 0 );
  469.     sgs_Release( C, T+29 );
  470.     sgs_StoreVariable( C, T+29 );
  471.     // concat
  472.     sgs_PushVariable( C, CN+22 );
  473.     sgs_PushVariable( C, T+29 );
  474.     sgs_Release( C, T+19 );
  475.     sgs_StringConcat( C, 2 );
  476.     sgs_StoreVariable( C, T+19 );
  477.     // getvar
  478.     sgs_Release( C, T+30 );
  479.     sgs_GetGlobalPP( C, CN+1, T+30 );
  480.     // sub
  481.     sgs_ArithOp( C, T+29, T+6, T+1, SGS_EOP_SUB );
  482.     // call
  483.     sgs_PushVariable( C, T+29 );
  484.     sgs_FCallP( C, T+30, 1, 1, 0 );
  485.     sgs_Release( C, T+29 );
  486.     sgs_StoreVariable( C, T+29 );
  487.     // concat
  488.     sgs_PushVariable( C, CN+23 );
  489.     sgs_PushVariable( C, T+29 );
  490.     sgs_Release( C, T+20 );
  491.     sgs_StringConcat( C, 2 );
  492.     sgs_StoreVariable( C, T+20 );
  493.     // getvar
  494.     sgs_Release( C, T+30 );
  495.     sgs_GetGlobalPP( C, CN+1, T+30 );
  496.     // sub
  497.     sgs_ArithOp( C, T+29, T+11, T+14, SGS_EOP_SUB );
  498.     // call
  499.     sgs_PushVariable( C, T+29 );
  500.     sgs_FCallP( C, T+30, 1, 1, 0 );
  501.     sgs_Release( C, T+29 );
  502.     sgs_StoreVariable( C, T+29 );
  503.     // concat
  504.     sgs_PushVariable( C, CN+24 );
  505.     sgs_PushVariable( C, T+29 );
  506.     sgs_Release( C, T+21 );
  507.     sgs_StringConcat( C, 2 );
  508.     sgs_StoreVariable( C, T+21 );
  509.     // getvar
  510.     sgs_Release( C, T+30 );
  511.     sgs_GetGlobalPP( C, CN+1, T+30 );
  512.     // sub
  513.     sgs_ArithOp( C, T+29, T+14, T+1, SGS_EOP_SUB );
  514.     // call
  515.     sgs_PushVariable( C, T+29 );
  516.     sgs_FCallP( C, T+30, 1, 1, 0 );
  517.     sgs_Release( C, T+29 );
  518.     sgs_StoreVariable( C, T+29 );
  519.     // concat
  520.     sgs_PushVariable( C, CN+25 );
  521.     sgs_PushVariable( C, T+29 );
  522.     sgs_Release( C, T+22 );
  523.     sgs_StringConcat( C, 2 );
  524.     sgs_StoreVariable( C, T+22 );
  525.     // set
  526.     sgs_Assign( C, T+23, CN+26 );
  527.     // concat
  528.     sgs_PushVariable( C, CN+19 );
  529.     sgs_PushVariable( C, T+2 );
  530.     sgs_Release( C, T+24 );
  531.     sgs_StringConcat( C, 2 );
  532.     sgs_StoreVariable( C, T+24 );
  533.     // concat
  534.     sgs_PushVariable( C, CN+20 );
  535.     sgs_PushVariable( C, T+7 );
  536.     sgs_Release( C, T+25 );
  537.     sgs_StringConcat( C, 2 );
  538.     sgs_StoreVariable( C, T+25 );
  539.     // concat
  540.     sgs_PushVariable( C, CN+21 );
  541.     sgs_PushVariable( C, T+12 );
  542.     sgs_Release( C, T+26 );
  543.     sgs_StringConcat( C, 2 );
  544.     sgs_StoreVariable( C, T+26 );
  545.     // call
  546.     sgs_PushVariable( C, T+15 );
  547.     sgs_PushVariable( C, T+16 );
  548.     sgs_PushVariable( C, T+17 );
  549.     sgs_PushVariable( C, T+18 );
  550.     sgs_PushVariable( C, T+19 );
  551.     sgs_PushVariable( C, T+20 );
  552.     sgs_PushVariable( C, T+21 );
  553.     sgs_PushVariable( C, T+22 );
  554.     sgs_PushVariable( C, T+23 );
  555.     sgs_PushVariable( C, T+24 );
  556.     sgs_PushVariable( C, T+25 );
  557.     sgs_PushVariable( C, T+26 );
  558.     sgs_FCallP( C, T+27, 12, 0, 0 );
  559.     // ---
  560.     _ret:
  561.     sgs_ReleaseArray( C, T, 32 );
  562.     sgs_ReleaseArray( C, CN, 27 );
  563.     return ret;
  564. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!