API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Mar 23rd, 2019
85
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 25.09 KB | None | 0 0
raw download clone embed print report
  1.  
  2. /* This file was generated automatically by the Snowball to ANSI C compiler */
  3.  
  4. #include "../runtime/header.h"
  5.  
  6. #ifdef __cplusplus
  7. extern "C" {
  8. #endif
  9. extern int porter_ISO_8859_1_stem(struct SN_env * z);
  10. #ifdef __cplusplus
  11. }
  12. #endif
  13. static int r_Step_5b(struct SN_env * z);
  14. static int r_Step_5a(struct SN_env * z);
  15. static int r_Step_4(struct SN_env * z);
  16. static int r_Step_3(struct SN_env * z);
  17. static int r_Step_2(struct SN_env * z);
  18. static int r_Step_1c(struct SN_env * z);
  19. static int r_Step_1b(struct SN_env * z);
  20. static int r_Step_1a(struct SN_env * z);
  21. static int r_R2(struct SN_env * z);
  22. static int r_R1(struct SN_env * z);
  23. static int r_shortv(struct SN_env * z);
  24. #ifdef __cplusplus
  25. extern "C" {
  26. #endif
  27.  
  28.  
  29. extern struct SN_env * porter_ISO_8859_1_create_env(void);
  30. extern void porter_ISO_8859_1_close_env(struct SN_env * z);
  31.  
  32.  
  33. #ifdef __cplusplus
  34. }
  35. #endif
  36. static const symbol s_0_0[1] = { 's' };
  37. static const symbol s_0_1[3] = { 'i', 'e', 's' };
  38. static const symbol s_0_2[4] = { 's', 's', 'e', 's' };
  39. static const symbol s_0_3[2] = { 's', 's' };
  40.  
  41. static const struct among a_0[4] =
  42. {
  43. /*  0 */ { 1, s_0_0, -1, 3, 0},
  44. /*  1 */ { 3, s_0_1, 0, 2, 0},
  45. /*  2 */ { 4, s_0_2, 0, 1, 0},
  46. /*  3 */ { 2, s_0_3, 0, -1, 0}
  47. };
  48.  
  49. static const symbol s_1_1[2] = { 'b', 'b' };
  50. static const symbol s_1_2[2] = { 'd', 'd' };
  51. static const symbol s_1_3[2] = { 'f', 'f' };
  52. static const symbol s_1_4[2] = { 'g', 'g' };
  53. static const symbol s_1_5[2] = { 'b', 'l' };
  54. static const symbol s_1_6[2] = { 'm', 'm' };
  55. static const symbol s_1_7[2] = { 'n', 'n' };
  56. static const symbol s_1_8[2] = { 'p', 'p' };
  57. static const symbol s_1_9[2] = { 'r', 'r' };
  58. static const symbol s_1_10[2] = { 'a', 't' };
  59. static const symbol s_1_11[2] = { 't', 't' };
  60. static const symbol s_1_12[2] = { 'i', 'z' };
  61.  
  62. static const struct among a_1[13] =
  63. {
  64. /*  0 */ { 0, 0, -1, 3, 0},
  65. /*  1 */ { 2, s_1_1, 0, 2, 0},
  66. /*  2 */ { 2, s_1_2, 0, 2, 0},
  67. /*  3 */ { 2, s_1_3, 0, 2, 0},
  68. /*  4 */ { 2, s_1_4, 0, 2, 0},
  69. /*  5 */ { 2, s_1_5, 0, 1, 0},
  70. /*  6 */ { 2, s_1_6, 0, 2, 0},
  71. /*  7 */ { 2, s_1_7, 0, 2, 0},
  72. /*  8 */ { 2, s_1_8, 0, 2, 0},
  73. /*  9 */ { 2, s_1_9, 0, 2, 0},
  74. /* 10 */ { 2, s_1_10, 0, 1, 0},
  75. /* 11 */ { 2, s_1_11, 0, 2, 0},
  76. /* 12 */ { 2, s_1_12, 0, 1, 0}
  77. };
  78.  
  79. static const symbol s_2_0[2] = { 'e', 'd' };
  80. static const symbol s_2_1[3] = { 'e', 'e', 'd' };
  81. static const symbol s_2_2[3] = { 'i', 'n', 'g' };
  82.  
  83. static const struct among a_2[3] =
  84. {
  85. /*  0 */ { 2, s_2_0, -1, 2, 0},
  86. /*  1 */ { 3, s_2_1, 0, 1, 0},
  87. /*  2 */ { 3, s_2_2, -1, 2, 0}
  88. };
  89.  
  90. static const symbol s_3_0[4] = { 'a', 'n', 'c', 'i' };
  91. static const symbol s_3_1[4] = { 'e', 'n', 'c', 'i' };
  92. static const symbol s_3_2[4] = { 'a', 'b', 'l', 'i' };
  93. static const symbol s_3_3[3] = { 'e', 'l', 'i' };
  94. static const symbol s_3_4[4] = { 'a', 'l', 'l', 'i' };
  95. static const symbol s_3_5[5] = { 'o', 'u', 's', 'l', 'i' };
  96. static const symbol s_3_6[5] = { 'e', 'n', 't', 'l', 'i' };
  97. static const symbol s_3_7[5] = { 'a', 'l', 'i', 't', 'i' };
  98. static const symbol s_3_8[6] = { 'b', 'i', 'l', 'i', 't', 'i' };
  99. static const symbol s_3_9[5] = { 'i', 'v', 'i', 't', 'i' };
  100. static const symbol s_3_10[6] = { 't', 'i', 'o', 'n', 'a', 'l' };
  101. static const symbol s_3_11[7] = { 'a', 't', 'i', 'o', 'n', 'a', 'l' };
  102. static const symbol s_3_12[5] = { 'a', 'l', 'i', 's', 'm' };
  103. static const symbol s_3_13[5] = { 'a', 't', 'i', 'o', 'n' };
  104. static const symbol s_3_14[7] = { 'i', 'z', 'a', 't', 'i', 'o', 'n' };
  105. static const symbol s_3_15[4] = { 'i', 'z', 'e', 'r' };
  106. static const symbol s_3_16[4] = { 'a', 't', 'o', 'r' };
  107. static const symbol s_3_17[7] = { 'i', 'v', 'e', 'n', 'e', 's', 's' };
  108. static const symbol s_3_18[7] = { 'f', 'u', 'l', 'n', 'e', 's', 's' };
  109. static const symbol s_3_19[7] = { 'o', 'u', 's', 'n', 'e', 's', 's' };
  110.  
  111. static const struct among a_3[20] =
  112. {
  113. /*  0 */ { 4, s_3_0, -1, 3, 0},
  114. /*  1 */ { 4, s_3_1, -1, 2, 0},
  115. /*  2 */ { 4, s_3_2, -1, 4, 0},
  116. /*  3 */ { 3, s_3_3, -1, 6, 0},
  117. /*  4 */ { 4, s_3_4, -1, 9, 0},
  118. /*  5 */ { 5, s_3_5, -1, 12, 0},
  119. /*  6 */ { 5, s_3_6, -1, 5, 0},
  120. /*  7 */ { 5, s_3_7, -1, 10, 0},
  121. /*  8 */ { 6, s_3_8, -1, 14, 0},
  122. /*  9 */ { 5, s_3_9, -1, 13, 0},
  123. /* 10 */ { 6, s_3_10, -1, 1, 0},
  124. /* 11 */ { 7, s_3_11, 10, 8, 0},
  125. /* 12 */ { 5, s_3_12, -1, 10, 0},
  126. /* 13 */ { 5, s_3_13, -1, 8, 0},
  127. /* 14 */ { 7, s_3_14, 13, 7, 0},
  128. /* 15 */ { 4, s_3_15, -1, 7, 0},
  129. /* 16 */ { 4, s_3_16, -1, 8, 0},
  130. /* 17 */ { 7, s_3_17, -1, 13, 0},
  131. /* 18 */ { 7, s_3_18, -1, 11, 0},
  132. /* 19 */ { 7, s_3_19, -1, 12, 0}
  133. };
  134.  
  135. static const symbol s_4_0[5] = { 'i', 'c', 'a', 't', 'e' };
  136. static const symbol s_4_1[5] = { 'a', 't', 'i', 'v', 'e' };
  137. static const symbol s_4_2[5] = { 'a', 'l', 'i', 'z', 'e' };
  138. static const symbol s_4_3[5] = { 'i', 'c', 'i', 't', 'i' };
  139. static const symbol s_4_4[4] = { 'i', 'c', 'a', 'l' };
  140. static const symbol s_4_5[3] = { 'f', 'u', 'l' };
  141. static const symbol s_4_6[4] = { 'n', 'e', 's', 's' };
  142.  
  143. static const struct among a_4[7] =
  144. {
  145. /*  0 */ { 5, s_4_0, -1, 2, 0},
  146. /*  1 */ { 5, s_4_1, -1, 3, 0},
  147. /*  2 */ { 5, s_4_2, -1, 1, 0},
  148. /*  3 */ { 5, s_4_3, -1, 2, 0},
  149. /*  4 */ { 4, s_4_4, -1, 2, 0},
  150. /*  5 */ { 3, s_4_5, -1, 3, 0},
  151. /*  6 */ { 4, s_4_6, -1, 3, 0}
  152. };
  153.  
  154. static const symbol s_5_0[2] = { 'i', 'c' };
  155. static const symbol s_5_1[4] = { 'a', 'n', 'c', 'e' };
  156. static const symbol s_5_2[4] = { 'e', 'n', 'c', 'e' };
  157. static const symbol s_5_3[4] = { 'a', 'b', 'l', 'e' };
  158. static const symbol s_5_4[4] = { 'i', 'b', 'l', 'e' };
  159. static const symbol s_5_5[3] = { 'a', 't', 'e' };
  160. static const symbol s_5_6[3] = { 'i', 'v', 'e' };
  161. static const symbol s_5_7[3] = { 'i', 'z', 'e' };
  162. static const symbol s_5_8[3] = { 'i', 't', 'i' };
  163. static const symbol s_5_9[2] = { 'a', 'l' };
  164. static const symbol s_5_10[3] = { 'i', 's', 'm' };
  165. static const symbol s_5_11[3] = { 'i', 'o', 'n' };
  166. static const symbol s_5_12[2] = { 'e', 'r' };
  167. static const symbol s_5_13[3] = { 'o', 'u', 's' };
  168. static const symbol s_5_14[3] = { 'a', 'n', 't' };
  169. static const symbol s_5_15[3] = { 'e', 'n', 't' };
  170. static const symbol s_5_16[4] = { 'm', 'e', 'n', 't' };
  171. static const symbol s_5_17[5] = { 'e', 'm', 'e', 'n', 't' };
  172. static const symbol s_5_18[2] = { 'o', 'u' };
  173.  
  174. static const struct among a_5[19] =
  175. {
  176. /*  0 */ { 2, s_5_0, -1, 1, 0},
  177. /*  1 */ { 4, s_5_1, -1, 1, 0},
  178. /*  2 */ { 4, s_5_2, -1, 1, 0},
  179. /*  3 */ { 4, s_5_3, -1, 1, 0},
  180. /*  4 */ { 4, s_5_4, -1, 1, 0},
  181. /*  5 */ { 3, s_5_5, -1, 1, 0},
  182. /*  6 */ { 3, s_5_6, -1, 1, 0},
  183. /*  7 */ { 3, s_5_7, -1, 1, 0},
  184. /*  8 */ { 3, s_5_8, -1, 1, 0},
  185. /*  9 */ { 2, s_5_9, -1, 1, 0},
  186. /* 10 */ { 3, s_5_10, -1, 1, 0},
  187. /* 11 */ { 3, s_5_11, -1, 2, 0},
  188. /* 12 */ { 2, s_5_12, -1, 1, 0},
  189. /* 13 */ { 3, s_5_13, -1, 1, 0},
  190. /* 14 */ { 3, s_5_14, -1, 1, 0},
  191. /* 15 */ { 3, s_5_15, -1, 1, 0},
  192. /* 16 */ { 4, s_5_16, 15, 1, 0},
  193. /* 17 */ { 5, s_5_17, 16, 1, 0},
  194. /* 18 */ { 2, s_5_18, -1, 1, 0}
  195. };
  196.  
  197. static const unsigned char g_v[] = { 17, 65, 16, 1 };
  198.  
  199. static const unsigned char g_v_WXY[] = { 1, 17, 65, 208, 1 };
  200.  
  201. static const symbol s_0[] = { 's', 's' };
  202. static const symbol s_1[] = { 'i' };
  203. static const symbol s_2[] = { 'e', 'e' };
  204. static const symbol s_3[] = { 'e' };
  205. static const symbol s_4[] = { 'e' };
  206. static const symbol s_5[] = { 'y' };
  207. static const symbol s_6[] = { 'Y' };
  208. static const symbol s_7[] = { 'i' };
  209. static const symbol s_8[] = { 't', 'i', 'o', 'n' };
  210. static const symbol s_9[] = { 'e', 'n', 'c', 'e' };
  211. static const symbol s_10[] = { 'a', 'n', 'c', 'e' };
  212. static const symbol s_11[] = { 'a', 'b', 'l', 'e' };
  213. static const symbol s_12[] = { 'e', 'n', 't' };
  214. static const symbol s_13[] = { 'e' };
  215. static const symbol s_14[] = { 'i', 'z', 'e' };
  216. static const symbol s_15[] = { 'a', 't', 'e' };
  217. static const symbol s_16[] = { 'a', 'l' };
  218. static const symbol s_17[] = { 'a', 'l' };
  219. static const symbol s_18[] = { 'f', 'u', 'l' };
  220. static const symbol s_19[] = { 'o', 'u', 's' };
  221. static const symbol s_20[] = { 'i', 'v', 'e' };
  222. static const symbol s_21[] = { 'b', 'l', 'e' };
  223. static const symbol s_22[] = { 'a', 'l' };
  224. static const symbol s_23[] = { 'i', 'c' };
  225. static const symbol s_24[] = { 's' };
  226. static const symbol s_25[] = { 't' };
  227. static const symbol s_26[] = { 'e' };
  228. static const symbol s_27[] = { 'l' };
  229. static const symbol s_28[] = { 'l' };
  230. static const symbol s_29[] = { 'y' };
  231. static const symbol s_30[] = { 'Y' };
  232. static const symbol s_31[] = { 'y' };
  233. static const symbol s_32[] = { 'Y' };
  234. static const symbol s_33[] = { 'Y' };
  235. static const symbol s_34[] = { 'y' };
  236.  
  237. static int r_shortv(struct SN_env * z) {
  238.     if (out_grouping_b(z, g_v_WXY, 89, 121, 0)) return 0;
  239.     if (in_grouping_b(z, g_v, 97, 121, 0)) return 0;
  240.     if (out_grouping_b(z, g_v, 97, 121, 0)) return 0;
  241.     return 1;
  242. }
  243.  
  244. static int r_R1(struct SN_env * z) {
  245.     if (!(z->I[0] <= z->c)) return 0;
  246.     return 1;
  247. }
  248.  
  249. static int r_R2(struct SN_env * z) {
  250.     if (!(z->I[1] <= z->c)) return 0;
  251.     return 1;
  252. }
  253.  
  254. static int r_Step_1a(struct SN_env * z) {
  255.     int among_var;
  256.     z->ket = z->c; /* [, line 25 */
  257.     if (z->c <= z->lb || z->p[z->c - 1] != 115) return 0;
  258.     among_var = find_among_b(z, a_0, 4); /* substring, line 25 */
  259.     if (!(among_var)) return 0;
  260.     z->bra = z->c; /* ], line 25 */
  261.     switch(among_var) {
  262.         case 0: return 0;
  263.         case 1:
  264.             {   int ret = slice_from_s(z, 2, s_0); /* <-, line 26 */
  265.                 if (ret < 0) return ret;
  266.             }
  267.             break;
  268.         case 2:
  269.             {   int ret = slice_from_s(z, 1, s_1); /* <-, line 27 */
  270.                 if (ret < 0) return ret;
  271.             }
  272.             break;
  273.         case 3:
  274.             {   int ret = slice_del(z); /* delete, line 29 */
  275.                 if (ret < 0) return ret;
  276.             }
  277.             break;
  278.     }
  279.     return 1;
  280. }
  281.  
  282. static int r_Step_1b(struct SN_env * z) {
  283.     int among_var;
  284.     z->ket = z->c; /* [, line 34 */
  285.     if (z->c - 1 <= z->lb || (z->p[z->c - 1] != 100 && z->p[z->c - 1] != 103)) return 0;
  286.     among_var = find_among_b(z, a_2, 3); /* substring, line 34 */
  287.     if (!(among_var)) return 0;
  288.     z->bra = z->c; /* ], line 34 */
  289.     switch(among_var) {
  290.         case 0: return 0;
  291.         case 1:
  292.             {   int ret = r_R1(z);
  293.                 if (ret == 0) return 0; /* call R1, line 35 */
  294.                 if (ret < 0) return ret;
  295.             }
  296.             {   int ret = slice_from_s(z, 2, s_2); /* <-, line 35 */
  297.                 if (ret < 0) return ret;
  298.             }
  299.             break;
  300.         case 2:
  301.             {   int m_test = z->l - z->c; /* test, line 38 */
  302.                 {    /* gopast */ /* grouping v, line 38 */
  303.                     int ret = out_grouping_b(z, g_v, 97, 121, 1);
  304.                     if (ret < 0) return 0;
  305.                     z->c -= ret;
  306.                 }
  307.                 z->c = z->l - m_test;
  308.             }
  309.             {   int ret = slice_del(z); /* delete, line 38 */
  310.                 if (ret < 0) return ret;
  311.             }
  312.             {   int m_test = z->l - z->c; /* test, line 39 */
  313.                 if (z->c - 1 <= z->lb || z->p[z->c - 1] >> 5 != 3 || !((68514004 >> (z->p[z->c - 1] & 0x1f)) & 1)) among_var = 3; else
  314.                 among_var = find_among_b(z, a_1, 13); /* substring, line 39 */
  315.                 if (!(among_var)) return 0;
  316.                 z->c = z->l - m_test;
  317.             }
  318.             switch(among_var) {
  319.                 case 0: return 0;
  320.                 case 1:
  321.                     {   int c_keep = z->c;
  322.                         int ret = insert_s(z, z->c, z->c, 1, s_3); /* <+, line 41 */
  323.                         z->c = c_keep;
  324.                         if (ret < 0) return ret;
  325.                     }
  326.                     break;
  327.                 case 2:
  328.                     z->ket = z->c; /* [, line 44 */
  329.                     if (z->c <= z->lb) return 0;
  330.                     z->c--; /* next, line 44 */
  331.                     z->bra = z->c; /* ], line 44 */
  332.                     {   int ret = slice_del(z); /* delete, line 44 */
  333.                         if (ret < 0) return ret;
  334.                     }
  335.                     break;
  336.                 case 3:
  337.                     if (z->c != z->I[0]) return 0; /* atmark, line 45 */
  338.                     {   int m_test = z->l - z->c; /* test, line 45 */
  339.                         {   int ret = r_shortv(z);
  340.                             if (ret == 0) return 0; /* call shortv, line 45 */
  341.                             if (ret < 0) return ret;
  342.                         }
  343.                         z->c = z->l - m_test;
  344.                     }
  345.                     {   int c_keep = z->c;
  346.                         int ret = insert_s(z, z->c, z->c, 1, s_4); /* <+, line 45 */
  347.                         z->c = c_keep;
  348.                         if (ret < 0) return ret;
  349.                     }
  350.                     break;
  351.             }
  352.             break;
  353.     }
  354.     return 1;
  355. }
  356.  
  357. static int r_Step_1c(struct SN_env * z) {
  358.     z->ket = z->c; /* [, line 52 */
  359.     {   int m1 = z->l - z->c; (void)m1; /* or, line 52 */
  360.         if (!(eq_s_b(z, 1, s_5))) goto lab1;
  361.         goto lab0;
  362.     lab1:
  363.         z->c = z->l - m1;
  364.         if (!(eq_s_b(z, 1, s_6))) return 0;
  365.     }
  366. lab0:
  367.     z->bra = z->c; /* ], line 52 */
  368.     {    /* gopast */ /* grouping v, line 53 */
  369.         int ret = out_grouping_b(z, g_v, 97, 121, 1);
  370.         if (ret < 0) return 0;
  371.         z->c -= ret;
  372.     }
  373.     {   int ret = slice_from_s(z, 1, s_7); /* <-, line 54 */
  374.         if (ret < 0) return ret;
  375.     }
  376.     return 1;
  377. }
  378.  
  379. static int r_Step_2(struct SN_env * z) {
  380.     int among_var;
  381.     z->ket = z->c; /* [, line 58 */
  382.     if (z->c - 2 <= z->lb || z->p[z->c - 1] >> 5 != 3 || !((815616 >> (z->p[z->c - 1] & 0x1f)) & 1)) return 0;
  383.     among_var = find_among_b(z, a_3, 20); /* substring, line 58 */
  384.     if (!(among_var)) return 0;
  385.     z->bra = z->c; /* ], line 58 */
  386.     {   int ret = r_R1(z);
  387.         if (ret == 0) return 0; /* call R1, line 58 */
  388.         if (ret < 0) return ret;
  389.     }
  390.     switch(among_var) {
  391.         case 0: return 0;
  392.         case 1:
  393.             {   int ret = slice_from_s(z, 4, s_8); /* <-, line 59 */
  394.                 if (ret < 0) return ret;
  395.             }
  396.             break;
  397.         case 2:
  398.             {   int ret = slice_from_s(z, 4, s_9); /* <-, line 60 */
  399.                 if (ret < 0) return ret;
  400.             }
  401.             break;
  402.         case 3:
  403.             {   int ret = slice_from_s(z, 4, s_10); /* <-, line 61 */
  404.                 if (ret < 0) return ret;
  405.             }
  406.             break;
  407.         case 4:
  408.             {   int ret = slice_from_s(z, 4, s_11); /* <-, line 62 */
  409.                 if (ret < 0) return ret;
  410.             }
  411.             break;
  412.         case 5:
  413.             {   int ret = slice_from_s(z, 3, s_12); /* <-, line 63 */
  414.                 if (ret < 0) return ret;
  415.             }
  416.             break;
  417.         case 6:
  418.             {   int ret = slice_from_s(z, 1, s_13); /* <-, line 64 */
  419.                 if (ret < 0) return ret;
  420.             }
  421.             break;
  422.         case 7:
  423.             {   int ret = slice_from_s(z, 3, s_14); /* <-, line 66 */
  424.                 if (ret < 0) return ret;
  425.             }
  426.             break;
  427.         case 8:
  428.             {   int ret = slice_from_s(z, 3, s_15); /* <-, line 68 */
  429.                 if (ret < 0) return ret;
  430.             }
  431.             break;
  432.         case 9:
  433.             {   int ret = slice_from_s(z, 2, s_16); /* <-, line 69 */
  434.                 if (ret < 0) return ret;
  435.             }
  436.             break;
  437.         case 10:
  438.             {   int ret = slice_from_s(z, 2, s_17); /* <-, line 71 */
  439.                 if (ret < 0) return ret;
  440.             }
  441.             break;
  442.         case 11:
  443.             {   int ret = slice_from_s(z, 3, s_18); /* <-, line 72 */
  444.                 if (ret < 0) return ret;
  445.             }
  446.             break;
  447.         case 12:
  448.             {   int ret = slice_from_s(z, 3, s_19); /* <-, line 74 */
  449.                 if (ret < 0) return ret;
  450.             }
  451.             break;
  452.         case 13:
  453.             {   int ret = slice_from_s(z, 3, s_20); /* <-, line 76 */
  454.                 if (ret < 0) return ret;
  455.             }
  456.             break;
  457.         case 14:
  458.             {   int ret = slice_from_s(z, 3, s_21); /* <-, line 77 */
  459.                 if (ret < 0) return ret;
  460.             }
  461.             break;
  462.     }
  463.     return 1;
  464. }
  465.  
  466. static int r_Step_3(struct SN_env * z) {
  467.     int among_var;
  468.     z->ket = z->c; /* [, line 82 */
  469.     if (z->c - 2 <= z->lb || z->p[z->c - 1] >> 5 != 3 || !((528928 >> (z->p[z->c - 1] & 0x1f)) & 1)) return 0;
  470.     among_var = find_among_b(z, a_4, 7); /* substring, line 82 */
  471.     if (!(among_var)) return 0;
  472.     z->bra = z->c; /* ], line 82 */
  473.     {   int ret = r_R1(z);
  474.         if (ret == 0) return 0; /* call R1, line 82 */
  475.         if (ret < 0) return ret;
  476.     }
  477.     switch(among_var) {
  478.         case 0: return 0;
  479.         case 1:
  480.             {   int ret = slice_from_s(z, 2, s_22); /* <-, line 83 */
  481.                 if (ret < 0) return ret;
  482.             }
  483.             break;
  484.         case 2:
  485.             {   int ret = slice_from_s(z, 2, s_23); /* <-, line 85 */
  486.                 if (ret < 0) return ret;
  487.             }
  488.             break;
  489.         case 3:
  490.             {   int ret = slice_del(z); /* delete, line 87 */
  491.                 if (ret < 0) return ret;
  492.             }
  493.             break;
  494.     }
  495.     return 1;
  496. }
  497.  
  498. static int r_Step_4(struct SN_env * z) {
  499.     int among_var;
  500.     z->ket = z->c; /* [, line 92 */
  501.     if (z->c - 1 <= z->lb || z->p[z->c - 1] >> 5 != 3 || !((3961384 >> (z->p[z->c - 1] & 0x1f)) & 1)) return 0;
  502.     among_var = find_among_b(z, a_5, 19); /* substring, line 92 */
  503.     if (!(among_var)) return 0;
  504.     z->bra = z->c; /* ], line 92 */
  505.     {   int ret = r_R2(z);
  506.         if (ret == 0) return 0; /* call R2, line 92 */
  507.         if (ret < 0) return ret;
  508.     }
  509.     switch(among_var) {
  510.         case 0: return 0;
  511.         case 1:
  512.             {   int ret = slice_del(z); /* delete, line 95 */
  513.                 if (ret < 0) return ret;
  514.             }
  515.             break;
  516.         case 2:
  517.             {   int m1 = z->l - z->c; (void)m1; /* or, line 96 */
  518.                 if (!(eq_s_b(z, 1, s_24))) goto lab1;
  519.                 goto lab0;
  520.             lab1:
  521.                 z->c = z->l - m1;
  522.                 if (!(eq_s_b(z, 1, s_25))) return 0;
  523.             }
  524.         lab0:
  525.             {   int ret = slice_del(z); /* delete, line 96 */
  526.                 if (ret < 0) return ret;
  527.             }
  528.             break;
  529.     }
  530.     return 1;
  531. }
  532.  
  533. static int r_Step_5a(struct SN_env * z) {
  534.     z->ket = z->c; /* [, line 101 */
  535.     if (!(eq_s_b(z, 1, s_26))) return 0;
  536.     z->bra = z->c; /* ], line 101 */
  537.     {   int m1 = z->l - z->c; (void)m1; /* or, line 102 */
  538.         {   int ret = r_R2(z);
  539.             if (ret == 0) goto lab1; /* call R2, line 102 */
  540.             if (ret < 0) return ret;
  541.         }
  542.         goto lab0;
  543.     lab1:
  544.         z->c = z->l - m1;
  545.         {   int ret = r_R1(z);
  546.             if (ret == 0) return 0; /* call R1, line 102 */
  547.             if (ret < 0) return ret;
  548.         }
  549.         {   int m2 = z->l - z->c; (void)m2; /* not, line 102 */
  550.             {   int ret = r_shortv(z);
  551.                 if (ret == 0) goto lab2; /* call shortv, line 102 */
  552.                 if (ret < 0) return ret;
  553.             }
  554.             return 0;
  555.         lab2:
  556.             z->c = z->l - m2;
  557.         }
  558.     }
  559. lab0:
  560.     {   int ret = slice_del(z); /* delete, line 103 */
  561.         if (ret < 0) return ret;
  562.     }
  563.     return 1;
  564. }
  565.  
  566. static int r_Step_5b(struct SN_env * z) {
  567.     z->ket = z->c; /* [, line 107 */
  568.     if (!(eq_s_b(z, 1, s_27))) return 0;
  569.     z->bra = z->c; /* ], line 107 */
  570.     {   int ret = r_R2(z);
  571.         if (ret == 0) return 0; /* call R2, line 108 */
  572.         if (ret < 0) return ret;
  573.     }
  574.     if (!(eq_s_b(z, 1, s_28))) return 0;
  575.     {   int ret = slice_del(z); /* delete, line 109 */
  576.         if (ret < 0) return ret;
  577.     }
  578.     return 1;
  579. }
  580.  
  581. extern int porter_ISO_8859_1_stem(struct SN_env * z) {
  582.     z->B[0] = 0; /* unset Y_found, line 115 */
  583.     {   int c1 = z->c; /* do, line 116 */
  584.         z->bra = z->c; /* [, line 116 */
  585.         if (!(eq_s(z, 1, s_29))) goto lab0;
  586.         z->ket = z->c; /* ], line 116 */
  587.         {   int ret = slice_from_s(z, 1, s_30); /* <-, line 116 */
  588.             if (ret < 0) return ret;
  589.         }
  590.         z->B[0] = 1; /* set Y_found, line 116 */
  591.     lab0:
  592.         z->c = c1;
  593.     }
  594.     {   int c2 = z->c; /* do, line 117 */
  595.         while(1) { /* repeat, line 117 */
  596.             int c3 = z->c;
  597.             while(1) { /* goto, line 117 */
  598.                 int c4 = z->c;
  599.                 if (in_grouping(z, g_v, 97, 121, 0)) goto lab3;
  600.                 z->bra = z->c; /* [, line 117 */
  601.                 if (!(eq_s(z, 1, s_31))) goto lab3;
  602.                 z->ket = z->c; /* ], line 117 */
  603.                 z->c = c4;
  604.                 break;
  605.             lab3:
  606.                 z->c = c4;
  607.                 if (z->c >= z->l) goto lab2;
  608.                 z->c++; /* goto, line 117 */
  609.             }
  610.             {   int ret = slice_from_s(z, 1, s_32); /* <-, line 117 */
  611.                 if (ret < 0) return ret;
  612.             }
  613.             z->B[0] = 1; /* set Y_found, line 117 */
  614.             continue;
  615.         lab2:
  616.             z->c = c3;
  617.             break;
  618.         }
  619.         z->c = c2;
  620.     }
  621.     z->I[0] = z->l;
  622.     z->I[1] = z->l;
  623.     {   int c5 = z->c; /* do, line 121 */
  624.         {    /* gopast */ /* grouping v, line 122 */
  625.             int ret = out_grouping(z, g_v, 97, 121, 1);
  626.             if (ret < 0) goto lab4;
  627.             z->c += ret;
  628.         }
  629.         {    /* gopast */ /* non v, line 122 */
  630.             int ret = in_grouping(z, g_v, 97, 121, 1);
  631.             if (ret < 0) goto lab4;
  632.             z->c += ret;
  633.         }
  634.         z->I[0] = z->c; /* setmark p1, line 122 */
  635.         {    /* gopast */ /* grouping v, line 123 */
  636.             int ret = out_grouping(z, g_v, 97, 121, 1);
  637.             if (ret < 0) goto lab4;
  638.             z->c += ret;
  639.         }
  640.         {    /* gopast */ /* non v, line 123 */
  641.             int ret = in_grouping(z, g_v, 97, 121, 1);
  642.             if (ret < 0) goto lab4;
  643.             z->c += ret;
  644.         }
  645.         z->I[1] = z->c; /* setmark p2, line 123 */
  646.     lab4:
  647.         z->c = c5;
  648.     }
  649.     z->lb = z->c; z->c = z->l; /* backwards, line 126 */
  650.  
  651.     {   int m6 = z->l - z->c; (void)m6; /* do, line 127 */
  652.         {   int ret = r_Step_1a(z);
  653.             if (ret == 0) goto lab5; /* call Step_1a, line 127 */
  654.             if (ret < 0) return ret;
  655.         }
  656.     lab5:
  657.         z->c = z->l - m6;
  658.     }
  659.     {   int m7 = z->l - z->c; (void)m7; /* do, line 128 */
  660.         {   int ret = r_Step_1b(z);
  661.             if (ret == 0) goto lab6; /* call Step_1b, line 128 */
  662.             if (ret < 0) return ret;
  663.         }
  664.     lab6:
  665.         z->c = z->l - m7;
  666.     }
  667.     {   int m8 = z->l - z->c; (void)m8; /* do, line 129 */
  668.         {   int ret = r_Step_1c(z);
  669.             if (ret == 0) goto lab7; /* call Step_1c, line 129 */
  670.             if (ret < 0) return ret;
  671.         }
  672.     lab7:
  673.         z->c = z->l - m8;
  674.     }
  675.     {   int m9 = z->l - z->c; (void)m9; /* do, line 130 */
  676.         {   int ret = r_Step_2(z);
  677.             if (ret == 0) goto lab8; /* call Step_2, line 130 */
  678.             if (ret < 0) return ret;
  679.         }
  680.     lab8:
  681.         z->c = z->l - m9;
  682.     }
  683.     {   int m10 = z->l - z->c; (void)m10; /* do, line 131 */
  684.         {   int ret = r_Step_3(z);
  685.             if (ret == 0) goto lab9; /* call Step_3, line 131 */
  686.             if (ret < 0) return ret;
  687.         }
  688.     lab9:
  689.         z->c = z->l - m10;
  690.     }
  691.     {   int m11 = z->l - z->c; (void)m11; /* do, line 132 */
  692.         {   int ret = r_Step_4(z);
  693.             if (ret == 0) goto lab10; /* call Step_4, line 132 */
  694.             if (ret < 0) return ret;
  695.         }
  696.     lab10:
  697.         z->c = z->l - m11;
  698.     }
  699.     {   int m12 = z->l - z->c; (void)m12; /* do, line 133 */
  700.         {   int ret = r_Step_5a(z);
  701.             if (ret == 0) goto lab11; /* call Step_5a, line 133 */
  702.             if (ret < 0) return ret;
  703.         }
  704.     lab11:
  705.         z->c = z->l - m12;
  706.     }
  707.     {   int m13 = z->l - z->c; (void)m13; /* do, line 134 */
  708.         {   int ret = r_Step_5b(z);
  709.             if (ret == 0) goto lab12; /* call Step_5b, line 134 */
  710.             if (ret < 0) return ret;
  711.         }
  712.     lab12:
  713.         z->c = z->l - m13;
  714.     }
  715.     z->c = z->lb;
  716.     {   int c14 = z->c; /* do, line 137 */
  717.         if (!(z->B[0])) goto lab13; /* Boolean test Y_found, line 137 */
  718.         while(1) { /* repeat, line 137 */
  719.             int c15 = z->c;
  720.             while(1) { /* goto, line 137 */
  721.                 int c16 = z->c;
  722.                 z->bra = z->c; /* [, line 137 */
  723.                 if (!(eq_s(z, 1, s_33))) goto lab15;
  724.                 z->ket = z->c; /* ], line 137 */
  725.                 z->c = c16;
  726.                 break;
  727.             lab15:
  728.                 z->c = c16;
  729.                 if (z->c >= z->l) goto lab14;
  730.                 z->c++; /* goto, line 137 */
  731.             }
  732.             {   int ret = slice_from_s(z, 1, s_34); /* <-, line 137 */
  733.                 if (ret < 0) return ret;
  734.             }
  735.             continue;
  736.         lab14:
  737.             z->c = c15;
  738.             break;
  739.         }
  740.     lab13:
  741.         z->c = c14;
  742.     }
  743.     return 1;
  744. }
  745.  
  746. extern struct SN_env * porter_ISO_8859_1_create_env(void) { return SN_create_env(0, 2, 1); }
  747.  
  748. extern void porter_ISO_8859_1_close_env(struct SN_env * z) { SN_close_env(z, 0); }
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!