test3.in
上传用户:gddssl
上传日期:2007-01-06
资源大小:1003k
文件大小:7k
源码类别:

编辑器/阅读器

开发平台:

DOS

  1. /* vim: set cin ts=4 sw=4 : */
  2. Test for 'cindent'
  3. STARTTEST
  4. :set nocompatible
  5. :edit                " read modeline
  6. /start of AUTO
  7. =/end of AUTO
  8. ENDTEST
  9. /* start of AUTO matically checked */
  10. {
  11. if (test)
  12. cmd1;
  13. cmd2;
  14. }
  15. {
  16. if (test)
  17. cmd1;
  18. else
  19. cmd2;
  20. }
  21. {
  22. if (test)
  23. {
  24. cmd1;
  25. cmd2;
  26. }
  27. }
  28. {
  29. if (test)
  30. {
  31. cmd1;
  32. else
  33. }
  34. }
  35. {
  36. while (this)
  37. if (test)
  38. cmd1;
  39. cmd2;
  40. }
  41. {
  42. while (this)
  43. if (test)
  44. cmd1;
  45. else
  46. cmd2;
  47. }
  48. {
  49. if (test)
  50. {
  51. cmd;
  52. }
  53. if (test)
  54. cmd;
  55. }
  56. {
  57. if (test) {
  58. cmd;
  59. }
  60. if (test) cmd;
  61. }
  62. {
  63. cmd1;
  64. for (blah)
  65. while (this)
  66. if (test)
  67. cmd2;
  68. cmd3;
  69. }
  70. {
  71. cmd1;
  72. for (blah)
  73. while (this)
  74. if (test)
  75. cmd2;
  76. cmd3;
  77. if (test)
  78. {
  79. cmd1;
  80. cmd2;
  81. cmd3;
  82. }
  83. }
  84. /* Test for 'cindent' do/while mixed with if/else: */
  85. {
  86. do
  87. if (asdf)
  88. asdfasd;
  89. while (cond);
  90. do
  91. if (asdf)
  92. while (asdf)
  93. asdf;
  94. while (asdf);
  95. }
  96. /* Test for 'cindent' with two ) on a continuation line */
  97. {
  98. if (asdfasdf;asldkfj asdlkfj as;ldkfj sal;d
  99. aal;sdkjf  ( ;asldfkja;sldfk
  100. al;sdjfka ;slkdf ) sa;ldkjfsa dlk;)
  101. line up here;
  102. }
  103. /* C++ tests: */
  104. // foo() these three lines should remain in column 0
  105. // {
  106. // }
  107. /* Test for continuation and unterminated lines: */
  108. {
  109. i = 99 + 14325 +
  110. 21345 +
  111. 21345 +
  112. 21345 + ( 21345 +
  113. 21345) +
  114. 2345 +
  115. 1234;
  116. c = 1;
  117. }
  118. /*
  119.    testje for indent with empty line
  120.    here */
  121. {
  122. if (testing &&
  123. not a joke ||
  124. line up here)
  125. hay;
  126. if (testing &&
  127. (not a joke || testing
  128. )line up here)
  129. hay;
  130. if (testing &&
  131. (not a joke || testing
  132.  line up here))
  133. hay;
  134. }
  135. {
  136. switch (c)
  137. {
  138. case xx:
  139. do
  140. if (asdf)
  141. do
  142. asdfasdf;
  143. while (asdf);
  144. else
  145. asdfasdf;
  146. while (cond);
  147. case yy:
  148. case xx:
  149. case zz:
  150. testing;
  151. }
  152. }
  153. {
  154. if (cond) {
  155. foo;
  156. }
  157. else
  158. {
  159. bar;
  160. }
  161. }
  162. {
  163. if (alskdfj ;alsdkfjal;skdjf (;sadlkfsa ;dlkf j;alksdfj ;alskdjf
  164. alsdkfj (asldk;fj
  165. awith cino=(0 ;lf this one goes to below the paren with ==
  166. ;laksjfd ;lsakdjf ;alskdf asd)
  167. asdfasdf;)))
  168. asdfasdf;
  169. }
  170. int
  171. func(a, b)
  172. int a;
  173. int c;
  174. {
  175. if (c1 && (c2 ||
  176. c3))
  177. foo;
  178. if (c1 &&
  179. (c2 || c3)
  180.    )
  181. }
  182. {
  183. while (asd)
  184. {
  185. if (asdf)
  186. if (test)
  187. if (that)
  188. {
  189. if (asdf)
  190. do
  191. cdasd;
  192. while (as
  193. df);
  194. }
  195. else
  196. if (asdf)
  197. asdf;
  198. else
  199. asdf;
  200. asdf;
  201. }
  202. }
  203. {
  204. s = "/*"; b = ';'
  205. s = "/*"; b = ';';
  206. a = b;
  207. }
  208. {
  209. switch (a)
  210. {
  211. case a:
  212. switch (t)
  213. {
  214. case 1:
  215. cmd;
  216. break;
  217. case 2:
  218. cmd;
  219. break;
  220. }
  221. cmd;
  222. break;
  223. case b:
  224. {
  225. int i;
  226. cmd;
  227. }
  228. break;
  229. case c: {
  230. int i;
  231. cmd;
  232. }
  233. case d: if (cond &&
  234. test) { /* this line doesn't work right */
  235. int i;
  236. cmd;
  237. }
  238. break;
  239. }
  240. }
  241. {
  242. if (!(vim_strchr(p_cpo, CPO_BUFOPTGLOB) != NULL && entering) &&
  243. (bp_to->b_p_initialized ||
  244.  (!entering && vim_strchr(p_cpo, CPO_BUFOPT) != NULL)))
  245. return;
  246. label :
  247. asdf = asdf ?
  248. asdf : asdf;
  249. asdf = asdf ?
  250. asdf: asdf;
  251. }
  252. /* Special Comments : This function has the added complexity (compared  */
  253. /* : to addtolist) of having to check for a detail     */
  254. /* : texture and add that to the list first.       */
  255. char *(array[100]) = {
  256. "testje",
  257. "foo",
  258. "bar",
  259. }
  260. {
  261. struct Type
  262. {
  263. int i;
  264. char *str;
  265. } var[] =
  266. {
  267. 0, "zero",
  268. 1, "one",
  269. 2, "two",
  270. 3, "three"
  271. };
  272. float matrix[3][3] =
  273. {
  274. {
  275. 0,
  276. 1,
  277. 2
  278. },
  279. {
  280. 3,
  281. 4,
  282. 5
  283. },
  284. {
  285. 6,
  286. 7,
  287. 8
  288. }
  289. };
  290. }
  291. {
  292. /* blah ( blah */
  293. /* where does this go? */
  294. /* blah ( blah */
  295. cmd;
  296. func(arg1,
  297. /* comment */
  298. arg2);
  299. a;
  300. {
  301. b;
  302. {
  303. c; /* Hey, NOW it indents?! */
  304. }
  305. }
  306. {
  307. func(arg1,
  308. arg2,
  309. arg3);
  310. /* Hey, what am I doing here?  Is this coz of the ","? */
  311. }
  312. }
  313. main ()
  314. {
  315. if (cond)
  316. {
  317. a = b;
  318. }
  319. if (cond) {
  320. a = c;
  321. }
  322. if (cond)
  323. a = d;
  324. return;
  325. }
  326. {
  327. case 2: if (asdf &&
  328. asdfasdf)
  329. aasdf;
  330. a = 9;
  331. case 3: if (asdf)
  332. aasdf;
  333. a = 9;
  334. case 4:    x = 1;
  335.    y = 2;
  336. label: if (asdf)
  337. here;
  338. label:  if (asdf &&
  339. asdfasdf)
  340. {
  341. }
  342. label:  if (asdf &&
  343. asdfasdf) {
  344. there;
  345. }
  346. label:  if (asdf &&
  347. asdfasdf)
  348. there;
  349. }
  350. {
  351. /*
  352.    hello with ":set comments= cino=c5"
  353.  */
  354. /*
  355.    hello with ":set comments= cino="
  356.  */
  357. }
  358. {
  359. if (a < b) {
  360. a = a + 1;
  361. } else
  362. a = a + 2;
  363. if (a)
  364. do {
  365. testing;
  366. } while (asdfasdf);
  367. a = b + 1;
  368. asdfasdf
  369. }
  370. class bob
  371. {
  372. int foo() {return 1;}
  373. int bar;
  374. }
  375. main()
  376. {
  377. while(1)
  378. if (foo)
  379. {
  380. bar;
  381. }
  382. else {
  383. asdf;
  384. }
  385. misplacedline;
  386. }
  387. {
  388. if (clipboard.state == SELECT_DONE
  389. && ((row == clipboard.start.lnum
  390. && col >= clipboard.start.col)
  391. || row > clipboard.start.lnum))
  392. }
  393. /* end of AUTO */
  394. STARTTEST
  395. :set tw=0 wm=60 columns=80 noai fo=croq
  396. /serious/e
  397. a about life, the universe, and the rest
  398. ENDTEST
  399. {
  400. /* this is
  401.  * a real serious important big
  402.  * comment
  403.  */
  404. /* insert " about life, the universe, and the rest" after "serious" */
  405. }
  406. STARTTEST
  407. :set nocin
  408. /comments
  409. joabout life/happens
  410. jothere/below
  411. oline/this
  412. Ohello
  413. ENDTEST
  414. {
  415. /*
  416.  * Testing for comments, without 'cin' set
  417.  */
  418. /*
  419. * what happens here?
  420. */
  421. /*
  422.    the end of the comment, try inserting a line below */
  423. /* how about
  424.                 this one */
  425. }
  426. STARTTEST
  427. :set cin
  428. /vec2
  429. ==
  430. ENDTEST
  431. {
  432.     var = this + that + vec[0] * vec[0]
  433.       + vec[1] * vec[1]
  434.   + vec2[2] * vec[2];
  435. }
  436. STARTTEST
  437. :set cin
  438. :set cino=}4
  439. /testing1
  440. k2==/testing2
  441. k2==
  442. ENDTEST
  443. {
  444. asdf asdflkajds f;
  445. if (tes & ting) {
  446. asdf asdf asdf ;
  447. asdfa sdf asdf;
  448. }
  449. testing1;
  450. if (tes & ting)
  451. {
  452. asdf asdf asdf ;
  453. asdfa sdf asdf;
  454. }
  455. testing2;
  456. }
  457. STARTTEST
  458. :set cin
  459. :set cino=(0,)20
  460. /main
  461. =][
  462. ENDTEST
  463. main ( int first_par, /*
  464.                        * Comment for
  465.                        * first par
  466.                        */
  467.           int second_par /*
  468.                        * Comment for
  469.                        * second par
  470.                        */
  471.      )
  472. {
  473. func( first_par, /*
  474.                       * Comment for
  475.                       * first par
  476.                       */
  477.     second_par /*
  478.                       * Comment for
  479.                       * second par
  480.                       */
  481.         );
  482. }
  483. STARTTEST
  484. :set cin
  485. :set cino=
  486. ]]=][
  487. ENDTEST
  488. {
  489. do
  490. {
  491. if ()
  492. {
  493. if ()
  494. asdf;
  495. else
  496. asdf;
  497. }
  498. } while ();
  499. cmd; /* this should go under the } */
  500. }
  501. STARTTEST
  502. ]]=][
  503. ENDTEST
  504. void f()
  505. {
  506.     if ( k() ) {
  507.         l();
  508.     } else { /* Start (two words) end */
  509.         m();
  510.     }
  511.     n();
  512. }
  513. STARTTEST
  514. /while
  515. ohere
  516. ENDTEST
  517. a()
  518. {
  519.   do {
  520.     a = a +
  521.       a;
  522.   } while ( a ); /* add text under this line */
  523.     if ( a )
  524.       a;
  525. }
  526. STARTTEST
  527. :1;/ENDTEST/+1,$wq! test.out
  528. ENDTEST