API tools faq
paste
Guest User

aur/sqlite2 build error log

a guest
May 19th, 2025
49
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 68.27 KB | Software | 0 0
raw download clone embed print report
  1. ./tool/lemon.c:32:14: error: conflicting types for ‘malloc’; have ‘void *(void)’
  2. 32 | extern void *malloc();
  3. | ^~~~~~
  4. In file included from ./tool/lemon.c:13:
  5. /usr/include/stdlib.h:672:14: note: previous declaration of ‘malloc’ with type ‘void *(long unsigned int)’
  6. 672 | extern void *malloc (size_t __size) __THROW __attribute_malloc__
  7. | ^~~~~~
  8. ./tool/lemon.c: In function ‘Action_new’:
  9. ./tool/lemon.c:337:33: error: too many arguments to function ‘malloc’; expected 0, have 1
  10. 337 | freelist = (struct action *)malloc( sizeof(struct action)*amt );
  11. | ^~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~
  12. ./tool/lemon.c:32:14: note: declared here
  13. 32 | extern void *malloc();
  14. | ^~~~~~
  15. ./tool/lemon.c: In function ‘actioncmp’:
  16. ./tool/lemon.c:351:12: warning: old-style function definition [-Wold-style-definition]
  17. 351 | static int actioncmp(ap1,ap2)
  18. | ^~~~~~~~~
  19. ./tool/lemon.c:41:29: error: too many arguments to function ‘myassert’; expected 0, have 2
  20. 41 | # define assert(X) if(!(X))myassert(__FILE__,__LINE__)
  21. | ^~~~~~~~
  22. ./tool/lemon.c:359:5: note: in expansion of macro ‘assert’
  23. 359 | assert( ap1->type==REDUCE || ap1->type==RD_RESOLVED || ap1->type==CONFLICT);
  24. | ^~~~~~
  25. ./tool/lemon.c:39:6: note: declared here
  26. 39 | void myassert();
  27. | ^~~~~~~~
  28. ./tool/lemon.c:41:29: error: too many arguments to function ‘myassert’; expected 0, have 2
  29. 41 | # define assert(X) if(!(X))myassert(__FILE__,__LINE__)
  30. | ^~~~~~~~
  31. ./tool/lemon.c:360:5: note: in expansion of macro ‘assert’
  32. 360 | assert( ap2->type==REDUCE || ap2->type==RD_RESOLVED || ap2->type==CONFLICT);
  33. | ^~~~~~
  34. ./tool/lemon.c:39:6: note: declared here
  35. 39 | void myassert();
  36. | ^~~~~~~~
  37. ./tool/lemon.c: In function ‘Action_sort’:
  38. ./tool/lemon.c:367:16: warning: old-style function definition [-Wold-style-definition]
  39. 367 | struct action *Action_sort(ap)
  40. | ^~~~~~~~~~~
  41. ./tool/lemon.c:369:1: error: number of arguments doesn’t match prototype
  42. 369 | {
  43. | ^
  44. ./tool/lemon.c:36:16: error: prototype declaration
  45. 36 | struct action *Action_sort();
  46. | ^~~~~~~~~~~
  47. ./tool/lemon.c:370:25: error: too many arguments to function ‘msort’; expected 0, have 3
  48. 370 | ap = (struct action *)msort((char *)ap,(char **)&ap->next,actioncmp);
  49. | ^~~~~ ~~~~~~~~~~
  50. ./tool/lemon.c:31:7: note: declared here
  51. 31 | char *msort();
  52. | ^~~~~
  53. ./tool/lemon.c: In function ‘Action_add’:
  54. ./tool/lemon.c:374:6: warning: old-style function definition [-Wold-style-definition]
  55. 374 | void Action_add(app,type,sp,arg)
  56. | ^~~~~~~~~~
  57. ./tool/lemon.c: In function ‘acttab_alloc’:
  58. ./tool/lemon.c:435:15: error: too many arguments to function ‘malloc’; expected 0, have 1
  59. 435 | acttab *p = malloc( sizeof(*p) );
  60. | ^~~~~~ ~~~~~~~~~~
  61. ./tool/lemon.c:32:14: note: declared here
  62. 32 | extern void *malloc();
  63. | ^~~~~~
  64. ./tool/lemon.c: In function ‘acttab_insert’:
  65. ./tool/lemon.c:41:29: error: too many arguments to function ‘myassert’; expected 0, have 2
  66. 41 | # define assert(X) if(!(X))myassert(__FILE__,__LINE__)
  67. | ^~~~~~~~
  68. ./tool/lemon.c:481:3: note: in expansion of macro ‘assert’
  69. 481 | assert( p->nLookahead>0 );
  70. | ^~~~~~
  71. ./tool/lemon.c:39:6: note: declared here
  72. 39 | void myassert();
  73. | ^~~~~~~~
  74. ./tool/lemon.c: In function ‘myassert’:
  75. ./tool/lemon.c:560:6: warning: old-style function definition [-Wold-style-definition]
  76. 560 | void myassert(file,line)
  77. | ^~~~~~~~
  78. ./tool/lemon.c:563:1: error: number of arguments doesn’t match prototype
  79. 563 | {
  80. | ^
  81. ./tool/lemon.c:39:6: error: prototype declaration
  82. 39 | void myassert();
  83. | ^~~~~~~~
  84. ./tool/lemon.c: In function ‘FindRulePrecedences’:
  85. ./tool/lemon.c:582:6: warning: old-style function definition [-Wold-style-definition]
  86. 582 | void FindRulePrecedences(xp)
  87. | ^~~~~~~~~~~~~~~~~~~
  88. ./tool/lemon.c:584:1: error: number of arguments doesn’t match prototype
  89. 584 | {
  90. | ^
  91. ./tool/lemon.c:47:6: error: prototype declaration
  92. 47 | void FindRulePrecedences();
  93. | ^~~~~~~~~~~~~~~~~~~
  94. ./tool/lemon.c: In function ‘FindFirstSets’:
  95. ./tool/lemon.c:605:6: warning: old-style function definition [-Wold-style-definition]
  96. 605 | void FindFirstSets(lemp)
  97. | ^~~~~~~~~~~~~
  98. ./tool/lemon.c:607:1: error: number of arguments doesn’t match prototype
  99. 607 | {
  100. | ^
  101. ./tool/lemon.c:48:6: error: prototype declaration
  102. 48 | void FindFirstSets();
  103. | ^~~~~~~~~~~~~
  104. ./tool/lemon.c:643:23: error: too many arguments to function ‘SetAdd’; expected 0, have 2
  105. 643 | progress += SetAdd(s1->firstset,s2->index);
  106. | ^~~~~~ ~~~~~~~~~~~~
  107. ./tool/lemon.c:104:5: note: declared here
  108. 104 | int SetAdd(/* char*,int */); /* Add element to a set */
  109. | ^~~~~~
  110. ./tool/lemon.c:648:23: error: too many arguments to function ‘SetUnion’; expected 0, have 2
  111. 648 | progress += SetUnion(s1->firstset,s2->firstset);
  112. | ^~~~~~~~ ~~~~~~~~~~~~
  113. ./tool/lemon.c:105:5: note: declared here
  114. 105 | int SetUnion(/* char *A,char *B */); /* A <- A U B, thru element N */
  115. | ^~~~~~~~
  116. ./tool/lemon.c: In function ‘FindStates’:
  117. ./tool/lemon.c:662:6: warning: old-style function definition [-Wold-style-definition]
  118. 662 | void FindStates(lemp)
  119. | ^~~~~~~~~~
  120. ./tool/lemon.c:664:1: error: number of arguments doesn’t match prototype
  121. 664 | {
  122. | ^
  123. ./tool/lemon.c:49:6: error: prototype declaration
  124. 49 | void FindStates();
  125. | ^~~~~~~~~~
  126. ./tool/lemon.c:672:10: error: too many arguments to function ‘Symbol_find’; expected 0, have 1
  127. 672 | sp = Symbol_find(lemp->start);
  128. | ^~~~~~~~~~~ ~~~~~~~~~~~
  129. ./tool/lemon.c:304:16: note: declared here
  130. 304 | struct symbol *Symbol_find(/* char * */);
  131. | ^~~~~~~~~~~
  132. ./tool/lemon.c:706:14: error: too many arguments to function ‘Configlist_addbasis’; expected 0, have 2
  133. 706 | newcfp = Configlist_addbasis(rp,0);
  134. | ^~~~~~~~~~~~~~~~~~~ ~~
  135. ./tool/lemon.c:57:16: note: declared here
  136. 57 | struct config *Configlist_addbasis(/* struct rule *, int */);
  137. | ^~~~~~~~~~~~~~~~~~~
  138. ./tool/lemon.c:707:5: error: too many arguments to function ‘SetAdd’; expected 0, have 2
  139. 707 | SetAdd(newcfp->fws,0);
  140. | ^~~~~~ ~~~~~~~~~~~
  141. ./tool/lemon.c:104:5: note: declared here
  142. 104 | int SetAdd(/* char*,int */); /* Add element to a set */
  143. | ^~~~~~
  144. ./tool/lemon.c:713:9: error: too many arguments to function ‘getstate’; expected 0, have 1
  145. 713 | (void)getstate(lemp);
  146. | ^~~~~~~~ ~~~~
  147. ./tool/lemon.c:661:23: note: declared here
  148. 661 | PRIVATE struct state *getstate(/* struct lemon * */); /* forward reference */
  149. | ^~~~~~~~
  150. ./tool/lemon.c: In function ‘getstate’:
  151. ./tool/lemon.c:721:23: warning: old-style function definition [-Wold-style-definition]
  152. 721 | PRIVATE struct state *getstate(lemp)
  153. | ^~~~~~~~
  154. ./tool/lemon.c:723:1: error: number of arguments doesn’t match prototype
  155. 723 | {
  156. | ^
  157. ./tool/lemon.c:661:23: error: prototype declaration
  158. 661 | PRIVATE struct state *getstate(/* struct lemon * */); /* forward reference */
  159. | ^~~~~~~~
  160. ./tool/lemon.c:733:9: error: too many arguments to function ‘State_find’; expected 0, have 1
  161. 733 | stp = State_find(bp);
  162. | ^~~~~~~~~~ ~~
  163. ./tool/lemon.c:315:15: note: declared here
  164. 315 | struct state *State_find(/* struct config * */);
  165. | ^~~~~~~~~~
  166. ./tool/lemon.c:740:7: error: too many arguments to function ‘Plink_copy’; expected 0, have 2
  167. 740 | Plink_copy(&y->bplp,x->bplp);
  168. | ^~~~~~~~~~ ~~~~~~~~
  169. ./tool/lemon.c:89:6: note: declared here
  170. 89 | void Plink_copy(/* struct plink **, struct plink * */);
  171. | ^~~~~~~~~~
  172. ./tool/lemon.c:741:7: error: too many arguments to function ‘Plink_delete’; expected 0, have 1
  173. 741 | Plink_delete(x->fplp);
  174. | ^~~~~~~~~~~~ ~~~~~~~
  175. ./tool/lemon.c:90:6: note: declared here
  176. 90 | void Plink_delete(/* struct plink * */);
  177. | ^~~~~~~~~~~~
  178. ./tool/lemon.c:745:5: error: too many arguments to function ‘Configlist_eat’; expected 0, have 1
  179. 745 | Configlist_eat(cfp);
  180. | ^~~~~~~~~~~~~~ ~~~
  181. ./tool/lemon.c:63:6: note: declared here
  182. 63 | void Configlist_eat(/* struct config * */);
  183. | ^~~~~~~~~~~~~~
  184. ./tool/lemon.c:748:5: error: too many arguments to function ‘Configlist_closure’; expected 0, have 1
  185. 748 | Configlist_closure(lemp); /* Compute the configuration closure */
  186. | ^~~~~~~~~~~~~~~~~~ ~~~~
  187. ./tool/lemon.c:58:6: note: declared here
  188. 58 | void Configlist_closure(/* void */);
  189. | ^~~~~~~~~~~~~~~~~~
  190. ./tool/lemon.c:757:5: error: too many arguments to function ‘State_insert’; expected 0, have 2
  191. 757 | State_insert(stp,stp->bp); /* Add to the state table */
  192. | ^~~~~~~~~~~~ ~~~
  193. ./tool/lemon.c:314:5: note: declared here
  194. 314 | int State_insert(/* struct state *, struct config * */);
  195. | ^~~~~~~~~~~~
  196. ./tool/lemon.c:758:5: error: too many arguments to function ‘buildshifts’; expected 0, have 2
  197. 758 | buildshifts(lemp,stp); /* Recursively compute successor states */
  198. | ^~~~~~~~~~~ ~~~~
  199. ./tool/lemon.c:720:14: note: declared here
  200. 720 | PRIVATE void buildshifts(/* struct lemon *, struct state * */); /* Forwd ref */
  201. | ^~~~~~~~~~~
  202. ./tool/lemon.c: In function ‘buildshifts’:
  203. ./tool/lemon.c:766:14: warning: old-style function definition [-Wold-style-definition]
  204. 766 | PRIVATE void buildshifts(lemp,stp)
  205. | ^~~~~~~~~~~
  206. ./tool/lemon.c:769:1: error: number of arguments doesn’t match prototype
  207. 769 | {
  208. | ^
  209. ./tool/lemon.c:720:14: error: prototype declaration
  210. 720 | PRIVATE void buildshifts(/* struct lemon *, struct state * */); /* Forwd ref */
  211. | ^~~~~~~~~~~
  212. ./tool/lemon.c:797:13: error: too many arguments to function ‘Configlist_addbasis’; expected 0, have 2
  213. 797 | new = Configlist_addbasis(bcfp->rp,bcfp->dot+1);
  214. | ^~~~~~~~~~~~~~~~~~~ ~~~~~~~~
  215. ./tool/lemon.c:57:16: note: declared here
  216. 57 | struct config *Configlist_addbasis(/* struct rule *, int */);
  217. | ^~~~~~~~~~~~~~~~~~~
  218. ./tool/lemon.c:798:7: error: too many arguments to function ‘Plink_add’; expected 0, have 2
  219. 798 | Plink_add(&new->bplp,bcfp);
  220. | ^~~~~~~~~ ~~~~~~~~~~
  221. ./tool/lemon.c:88:6: note: declared here
  222. 88 | void Plink_add(/* struct plink **, struct config * */);
  223. | ^~~~~~~~~
  224. ./tool/lemon.c:803:14: error: too many arguments to function ‘getstate’; expected 0, have 1
  225. 803 | newstp = getstate(lemp);
  226. | ^~~~~~~~ ~~~~
  227. ./tool/lemon.c:721:23: note: declared here
  228. 721 | PRIVATE struct state *getstate(lemp)
  229. | ^~~~~~~~
  230. ./tool/lemon.c: In function ‘FindLinks’:
  231. ./tool/lemon.c:814:6: warning: old-style function definition [-Wold-style-definition]
  232. 814 | void FindLinks(lemp)
  233. | ^~~~~~~~~
  234. ./tool/lemon.c:816:1: error: number of arguments doesn’t match prototype
  235. 816 | {
  236. | ^
  237. ./tool/lemon.c:50:6: error: prototype declaration
  238. 50 | void FindLinks();
  239. | ^~~~~~~~~
  240. ./tool/lemon.c:839:9: error: too many arguments to function ‘Plink_add’; expected 0, have 2
  241. 839 | Plink_add(&other->fplp,cfp);
  242. | ^~~~~~~~~ ~~~~~~~~~~~~
  243. ./tool/lemon.c:88:6: note: declared here
  244. 88 | void Plink_add(/* struct plink **, struct config * */);
  245. | ^~~~~~~~~
  246. ./tool/lemon.c: In function ‘FindFollowSets’:
  247. ./tool/lemon.c:850:6: warning: old-style function definition [-Wold-style-definition]
  248. 850 | void FindFollowSets(lemp)
  249. | ^~~~~~~~~~~~~~
  250. ./tool/lemon.c:852:1: error: number of arguments doesn’t match prototype
  251. 852 | {
  252. | ^
  253. ./tool/lemon.c:51:6: error: prototype declaration
  254. 51 | void FindFollowSets();
  255. | ^~~~~~~~~~~~~~
  256. ./tool/lemon.c:871:20: error: too many arguments to function ‘SetUnion’; expected 0, have 2
  257. 871 | change = SetUnion(plp->cfp->fws,cfp->fws);
  258. | ^~~~~~~~ ~~~~~~~~~~~~~
  259. ./tool/lemon.c:105:5: note: declared here
  260. 105 | int SetUnion(/* char *A,char *B */); /* A <- A U B, thru element N */
  261. | ^~~~~~~~
  262. ./tool/lemon.c: In function ‘FindActions’:
  263. ./tool/lemon.c:887:6: warning: old-style function definition [-Wold-style-definition]
  264. 887 | void FindActions(lemp)
  265. | ^~~~~~~~~~~
  266. ./tool/lemon.c:889:1: error: number of arguments doesn’t match prototype
  267. 889 | {
  268. | ^
  269. ./tool/lemon.c:52:6: error: prototype declaration
  270. 52 | void FindActions();
  271. | ^~~~~~~~~~~
  272. ./tool/lemon.c:917:10: error: too many arguments to function ‘Symbol_find’; expected 0, have 1
  273. 917 | sp = Symbol_find(lemp->start);
  274. | ^~~~~~~~~~~ ~~~~~~~~~~~
  275. ./tool/lemon.c:304:16: note: declared here
  276. 304 | struct symbol *Symbol_find(/* char * */);
  277. | ^~~~~~~~~~~
  278. ./tool/lemon.c:41:29: error: too many arguments to function ‘myassert’; expected 0, have 2
  279. 41 | # define assert(X) if(!(X))myassert(__FILE__,__LINE__)
  280. | ^~~~~~~~
  281. ./tool/lemon.c:932:5: note: in expansion of macro ‘assert’
  282. 932 | assert( stp->ap );
  283. | ^~~~~~
  284. ./tool/lemon.c:560:6: note: declared here
  285. 560 | void myassert(file,line)
  286. | ^~~~~~~~
  287. ./tool/lemon.c:933:15: error: too many arguments to function ‘Action_sort’; expected 0, have 1
  288. 933 | stp->ap = Action_sort(stp->ap);
  289. | ^~~~~~~~~~~ ~~~~~~~
  290. ./tool/lemon.c:367:16: note: declared here
  291. 367 | struct action *Action_sort(ap)
  292. | ^~~~~~~~~~~
  293. ./tool/lemon.c:938:29: error: too many arguments to function ‘resolve_conflict’; expected 0, have 3
  294. 938 | lemp->nconflict += resolve_conflict(ap,nap,lemp->errsym);
  295. | ^~~~~~~~~~~~~~~~ ~~
  296. ./tool/lemon.c:883:12: note: declared here
  297. 883 | static int resolve_conflict();
  298. | ^~~~~~~~~~~~~~~~
  299. ./tool/lemon.c: In function ‘resolve_conflict’:
  300. ./tool/lemon.c:971:12: warning: old-style function definition [-Wold-style-definition]
  301. 971 | static int resolve_conflict(apx,apy,errsym)
  302. | ^~~~~~~~~~~~~~~~
  303. ./tool/lemon.c:41:29: error: too many arguments to function ‘myassert’; expected 0, have 2
  304. 41 | # define assert(X) if(!(X))myassert(__FILE__,__LINE__)
  305. | ^~~~~~~~
  306. ./tool/lemon.c:978:3: note: in expansion of macro ‘assert’
  307. 978 | assert( apx->sp==apy->sp ); /* Otherwise there would be no conflict */
  308. | ^~~~~~
  309. ./tool/lemon.c:560:6: note: declared here
  310. 560 | void myassert(file,line)
  311. | ^~~~~~~~
  312. ./tool/lemon.c:41:29: error: too many arguments to function ‘myassert’; expected 0, have 2
  313. 41 | # define assert(X) if(!(X))myassert(__FILE__,__LINE__)
  314. | ^~~~~~~~
  315. ./tool/lemon.c:995:7: note: in expansion of macro ‘assert’
  316. 995 | assert( spx->prec==spy->prec && spx->assoc==NONE );
  317. | ^~~~~~
  318. ./tool/lemon.c:560:6: note: declared here
  319. 560 | void myassert(file,line)
  320. | ^~~~~~~~
  321. ./tool/lemon.c:41:29: error: too many arguments to function ‘myassert’; expected 0, have 2
  322. 41 | # define assert(X) if(!(X))myassert(__FILE__,__LINE__)
  323. | ^~~~~~~~
  324. ./tool/lemon.c:1012:5: note: in expansion of macro ‘assert’
  325. 1012 | assert(
  326. | ^~~~~~
  327. ./tool/lemon.c:560:6: note: declared here
  328. 560 | void myassert(file,line)
  329. | ^~~~~~~~
  330. ./tool/lemon.c: In function ‘newconfig’:
  331. ./tool/lemon.c:1044:33: error: too many arguments to function ‘malloc’; expected 0, have 1
  332. 1044 | freelist = (struct config *)malloc( sizeof(struct config)*amt );
  333. | ^~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~
  334. ./tool/lemon.c:32:14: note: declared here
  335. 32 | extern void *malloc();
  336. | ^~~~~~
  337. ./tool/lemon.c: In function ‘deleteconfig’:
  338. ./tool/lemon.c:1058:14: warning: old-style function definition [-Wold-style-definition]
  339. 1058 | PRIVATE void deleteconfig(old)
  340. | ^~~~~~~~~~~~
  341. ./tool/lemon.c: In function ‘Configlist_reset’:
  342. ./tool/lemon.c:1081:3: error: too many arguments to function ‘Configtable_clear’; expected 0, have 1
  343. 1081 | Configtable_clear(0);
  344. | ^~~~~~~~~~~~~~~~~ ~
  345. ./tool/lemon.c:323:6: note: declared here
  346. 323 | void Configtable_clear(/* int(*)(struct config *) */);
  347. | ^~~~~~~~~~~~~~~~~
  348. ./tool/lemon.c: In function ‘Configlist_add’:
  349. ./tool/lemon.c:1086:16: warning: old-style function definition [-Wold-style-definition]
  350. 1086 | struct config *Configlist_add(rp,dot)
  351. | ^~~~~~~~~~~~~~
  352. ./tool/lemon.c:1089:1: error: number of arguments doesn’t match prototype
  353. 1089 | {
  354. | ^
  355. ./tool/lemon.c:56:16: error: prototype declaration
  356. 56 | struct config *Configlist_add(/* struct rule *, int */);
  357. | ^~~~~~~~~~~~~~
  358. ./tool/lemon.c:41:29: error: too many arguments to function ‘myassert’; expected 0, have 2
  359. 41 | # define assert(X) if(!(X))myassert(__FILE__,__LINE__)
  360. | ^~~~~~~~
  361. ./tool/lemon.c:1092:3: note: in expansion of macro ‘assert’
  362. 1092 | assert( currentend!=0 );
  363. | ^~~~~~
  364. ./tool/lemon.c:560:6: note: declared here
  365. 560 | void myassert(file,line)
  366. | ^~~~~~~~
  367. ./tool/lemon.c:1095:9: error: too many arguments to function ‘Configtable_find’; expected 0, have 1
  368. 1095 | cfp = Configtable_find(&model);
  369. | ^~~~~~~~~~~~~~~~ ~~~~~~
  370. ./tool/lemon.c:322:16: note: declared here
  371. 322 | struct config *Configtable_find(/* struct config * */);
  372. | ^~~~~~~~~~~~~~~~
  373. ./tool/lemon.c:1107:5: error: too many arguments to function ‘Configtable_insert’; expected 0, have 1
  374. 1107 | Configtable_insert(cfp);
  375. | ^~~~~~~~~~~~~~~~~~ ~~~
  376. ./tool/lemon.c:321:5: note: declared here
  377. 321 | int Configtable_insert(/* struct config * */);
  378. | ^~~~~~~~~~~~~~~~~~
  379. ./tool/lemon.c: In function ‘Configlist_addbasis’:
  380. ./tool/lemon.c:1113:16: warning: old-style function definition [-Wold-style-definition]
  381. 1113 | struct config *Configlist_addbasis(rp,dot)
  382. | ^~~~~~~~~~~~~~~~~~~
  383. ./tool/lemon.c:1116:1: error: number of arguments doesn’t match prototype
  384. 1116 | {
  385. | ^
  386. ./tool/lemon.c:57:16: error: prototype declaration
  387. 57 | struct config *Configlist_addbasis(/* struct rule *, int */);
  388. | ^~~~~~~~~~~~~~~~~~~
  389. ./tool/lemon.c:41:29: error: too many arguments to function ‘myassert’; expected 0, have 2
  390. 41 | # define assert(X) if(!(X))myassert(__FILE__,__LINE__)
  391. | ^~~~~~~~
  392. ./tool/lemon.c:1119:3: note: in expansion of macro ‘assert’
  393. 1119 | assert( basisend!=0 );
  394. | ^~~~~~
  395. ./tool/lemon.c:560:6: note: declared here
  396. 560 | void myassert(file,line)
  397. | ^~~~~~~~
  398. ./tool/lemon.c:41:29: error: too many arguments to function ‘myassert’; expected 0, have 2
  399. 41 | # define assert(X) if(!(X))myassert(__FILE__,__LINE__)
  400. | ^~~~~~~~
  401. ./tool/lemon.c:1120:3: note: in expansion of macro ‘assert’
  402. 1120 | assert( currentend!=0 );
  403. | ^~~~~~
  404. ./tool/lemon.c:560:6: note: declared here
  405. 560 | void myassert(file,line)
  406. | ^~~~~~~~
  407. ./tool/lemon.c:1123:9: error: too many arguments to function ‘Configtable_find’; expected 0, have 1
  408. 1123 | cfp = Configtable_find(&model);
  409. | ^~~~~~~~~~~~~~~~ ~~~~~~
  410. ./tool/lemon.c:322:16: note: declared here
  411. 322 | struct config *Configtable_find(/* struct config * */);
  412. | ^~~~~~~~~~~~~~~~
  413. ./tool/lemon.c:1137:5: error: too many arguments to function ‘Configtable_insert’; expected 0, have 1
  414. 1137 | Configtable_insert(cfp);
  415. | ^~~~~~~~~~~~~~~~~~ ~~~
  416. ./tool/lemon.c:321:5: note: declared here
  417. 321 | int Configtable_insert(/* struct config * */);
  418. | ^~~~~~~~~~~~~~~~~~
  419. ./tool/lemon.c: In function ‘Configlist_closure’:
  420. ./tool/lemon.c:1143:6: warning: old-style function definition [-Wold-style-definition]
  421. 1143 | void Configlist_closure(lemp)
  422. | ^~~~~~~~~~~~~~~~~~
  423. ./tool/lemon.c:1145:1: error: number of arguments doesn’t match prototype
  424. 1145 | {
  425. | ^
  426. ./tool/lemon.c:58:6: error: prototype declaration
  427. 58 | void Configlist_closure(/* void */);
  428. | ^~~~~~~~~~~~~~~~~~
  429. ./tool/lemon.c:41:29: error: too many arguments to function ‘myassert’; expected 0, have 2
  430. 41 | # define assert(X) if(!(X))myassert(__FILE__,__LINE__)
  431. | ^~~~~~~~
  432. ./tool/lemon.c:1151:3: note: in expansion of macro ‘assert’
  433. 1151 | assert( currentend!=0 );
  434. | ^~~~~~
  435. ./tool/lemon.c:560:6: note: declared here
  436. 560 | void myassert(file,line)
  437. | ^~~~~~~~
  438. ./tool/lemon.c:1164:18: error: too many arguments to function ‘Configlist_add’; expected 0, have 2
  439. 1164 | newcfp = Configlist_add(newrp,0);
  440. | ^~~~~~~~~~~~~~ ~~~~~
  441. ./tool/lemon.c:1086:16: note: declared here
  442. 1086 | struct config *Configlist_add(rp,dot)
  443. | ^~~~~~~~~~~~~~
  444. ./tool/lemon.c:1168:13: error: too many arguments to function ‘SetAdd’; expected 0, have 2
  445. 1168 | SetAdd(newcfp->fws,xsp->index);
  446. | ^~~~~~ ~~~~~~~~~~~
  447. ./tool/lemon.c:104:5: note: declared here
  448. 104 | int SetAdd(/* char*,int */); /* Add element to a set */
  449. | ^~~~~~
  450. ./tool/lemon.c:1171:13: error: too many arguments to function ‘SetUnion’; expected 0, have 2
  451. 1171 | SetUnion(newcfp->fws,xsp->firstset);
  452. | ^~~~~~~~ ~~~~~~~~~~~
  453. ./tool/lemon.c:105:5: note: declared here
  454. 105 | int SetUnion(/* char *A,char *B */); /* A <- A U B, thru element N */
  455. | ^~~~~~~~
  456. ./tool/lemon.c:1175:27: error: too many arguments to function ‘Plink_add’; expected 0, have 2
  457. 1175 | if( i==rp->nrhs ) Plink_add(&cfp->fplp,newcfp);
  458. | ^~~~~~~~~ ~~~~~~~~~~
  459. ./tool/lemon.c:88:6: note: declared here
  460. 88 | void Plink_add(/* struct plink **, struct config * */);
  461. | ^~~~~~~~~
  462. ./tool/lemon.c: In function ‘Configlist_sort’:
  463. ./tool/lemon.c:1184:30: error: too many arguments to function ‘msort’; expected 0, have 3
  464. 1184 | current = (struct config *)msort((char *)current,(char **)&(current->next),Configcmp);
  465. | ^~~~~ ~~~~~~~~~~~~~~~
  466. ./tool/lemon.c:31:7: note: declared here
  467. 31 | char *msort();
  468. | ^~~~~
  469. ./tool/lemon.c: In function ‘Configlist_sortbasis’:
  470. ./tool/lemon.c:1191:28: error: too many arguments to function ‘msort’; expected 0, have 3
  471. 1191 | basis = (struct config *)msort((char *)current,(char **)&(current->bp),Configcmp);
  472. | ^~~~~ ~~~~~~~~~~~~~~~
  473. ./tool/lemon.c:31:7: note: declared here
  474. 31 | char *msort();
  475. | ^~~~~
  476. ./tool/lemon.c: In function ‘Configlist_eat’:
  477. ./tool/lemon.c:1217:6: warning: old-style function definition [-Wold-style-definition]
  478. 1217 | void Configlist_eat(cfp)
  479. | ^~~~~~~~~~~~~~
  480. ./tool/lemon.c:1219:1: error: number of arguments doesn’t match prototype
  481. 1219 | {
  482. | ^
  483. ./tool/lemon.c:63:6: error: prototype declaration
  484. 63 | void Configlist_eat(/* struct config * */);
  485. | ^~~~~~~~~~~~~~
  486. ./tool/lemon.c:41:29: error: too many arguments to function ‘myassert’; expected 0, have 2
  487. 41 | # define assert(X) if(!(X))myassert(__FILE__,__LINE__)
  488. | ^~~~~~~~
  489. ./tool/lemon.c:1223:5: note: in expansion of macro ‘assert’
  490. 1223 | assert( cfp->fplp==0 );
  491. | ^~~~~~
  492. ./tool/lemon.c:560:6: note: declared here
  493. 560 | void myassert(file,line)
  494. | ^~~~~~~~
  495. ./tool/lemon.c:41:29: error: too many arguments to function ‘myassert’; expected 0, have 2
  496. 41 | # define assert(X) if(!(X))myassert(__FILE__,__LINE__)
  497. | ^~~~~~~~
  498. ./tool/lemon.c:1224:5: note: in expansion of macro ‘assert’
  499. 1224 | assert( cfp->bplp==0 );
  500. | ^~~~~~
  501. ./tool/lemon.c:560:6: note: declared here
  502. 560 | void myassert(file,line)
  503. | ^~~~~~~~
  504. ./tool/lemon.c:1225:20: error: too many arguments to function ‘SetFree’; expected 0, have 1
  505. 1225 | if( cfp->fws ) SetFree(cfp->fws);
  506. | ^~~~~~~ ~~~~~~~~
  507. ./tool/lemon.c:102:7: note: declared here
  508. 102 | void SetFree(/* char* */); /* Deallocate a set */
  509. | ^~~~~~~
  510. ./tool/lemon.c: In function ‘findbreak’:
  511. ./tool/lemon.c:1238:12: warning: old-style function definition [-Wold-style-definition]
  512. 1238 | static int findbreak(msg,min,max)
  513. | ^~~~~~~~~
  514. ./tool/lemon.c: In function ‘main’:
  515. ./tool/lemon.c:1317:5: warning: old-style function definition [-Wold-style-definition]
  516. 1317 | int main(argc,argv)
  517. | ^~~~
  518. ./tool/lemon.c:1341:3: error: too many arguments to function ‘OptInit’; expected 0, have 3
  519. 1341 | OptInit(argv,options,stderr);
  520. | ^~~~~~~ ~~~~
  521. ./tool/lemon.c:77:8: note: declared here
  522. 77 | int OptInit(/* char**,struct s_options*,FILE* */);
  523. | ^~~~~~~
  524. ./tool/lemon.c:1357:18: error: too many arguments to function ‘OptArg’; expected 0, have 1
  525. 1357 | lem.filename = OptArg(0);
  526. | ^~~~~~ ~
  527. ./tool/lemon.c:79:8: note: declared here
  528. 79 | char *OptArg(/* int */);
  529. | ^~~~~~
  530. ./tool/lemon.c:1368:3: error: too many arguments to function ‘Symbol_new’; expected 0, have 1
  531. 1368 | Symbol_new("$");
  532. | ^~~~~~~~~~ ~~~
  533. ./tool/lemon.c:300:16: note: declared here
  534. 300 | struct symbol *Symbol_new();
  535. | ^~~~~~~~~~
  536. ./tool/lemon.c:1369:16: error: too many arguments to function ‘Symbol_new’; expected 0, have 1
  537. 1369 | lem.errsym = Symbol_new("error");
  538. | ^~~~~~~~~~ ~~~~~~~
  539. ./tool/lemon.c:300:16: note: declared here
  540. 300 | struct symbol *Symbol_new();
  541. | ^~~~~~~~~~
  542. ./tool/lemon.c:1372:3: error: too many arguments to function ‘Parse’; expected 0, have 1
  543. 1372 | Parse(&lem);
  544. | ^~~~~ ~~~~
  545. ./tool/lemon.c:84:6: note: declared here
  546. 84 | void Parse(/* struct lemon *lemp */);
  547. | ^~~~~
  548. ./tool/lemon.c:1381:3: error: too many arguments to function ‘Symbol_new’; expected 0, have 1
  549. 1381 | Symbol_new("{default}");
  550. | ^~~~~~~~~~ ~~~~~~~~~~~
  551. ./tool/lemon.c:300:16: note: declared here
  552. 300 | struct symbol *Symbol_new();
  553. | ^~~~~~~~~~
  554. ./tool/lemon.c:1385:9: error: passing argument 4 of ‘qsort’ from incompatible pointer type [-Wincompatible-pointer-types]
  555. 1385 | (int(*)())Symbolcmpp);
  556. | ^~~~~~~~~~~~~~~~~~~~
  557. | |
  558. | int (*)(void)
  559. /usr/include/stdlib.h:971:34: note: expected ‘__compar_fn_t’ {aka ‘int (*)(const void *, const void *)’} but argument is of type ‘int (*)(void)’
  560. 971 | __compar_fn_t __compar) __nonnull ((1, 4));
  561. | ~~~~~~~~~~~~~~^~~~~~~~
  562. ./tool/lemon.c:301:5: note: ‘Symbolcmpp’ declared here
  563. 301 | int Symbolcmpp(/* struct symbol **, struct symbol ** */);
  564. | ^~~~~~~~~~
  565. /usr/include/stdlib.h:948:15: note: ‘__compar_fn_t’ declared here
  566. 948 | typedef int (*__compar_fn_t) (const void *, const void *);
  567. | ^~~~~~~~~~~~~
  568. ./tool/lemon.c:1392:5: error: too many arguments to function ‘Reprint’; expected 0, have 1
  569. 1392 | Reprint(&lem);
  570. | ^~~~~~~ ~~~~
  571. ./tool/lemon.c:93:6: note: declared here
  572. 93 | void Reprint(/* struct lemon * */);
  573. | ^~~~~~~
  574. ./tool/lemon.c:1395:5: error: too many arguments to function ‘SetSize’; expected 0, have 1
  575. 1395 | SetSize(lem.nterminal);
  576. | ^~~~~~~ ~~~~~~~~~~~~~
  577. ./tool/lemon.c:100:7: note: declared here
  578. 100 | void SetSize(/* int N */); /* All sets will be of size N */
  579. | ^~~~~~~
  580. ./tool/lemon.c:1398:5: error: too many arguments to function ‘FindRulePrecedences’; expected 0, have 1
  581. 1398 | FindRulePrecedences(&lem);
  582. | ^~~~~~~~~~~~~~~~~~~ ~~~~
  583. ./tool/lemon.c:582:6: note: declared here
  584. 582 | void FindRulePrecedences(xp)
  585. | ^~~~~~~~~~~~~~~~~~~
  586. ./tool/lemon.c:1402:5: error: too many arguments to function ‘FindFirstSets’; expected 0, have 1
  587. 1402 | FindFirstSets(&lem);
  588. | ^~~~~~~~~~~~~ ~~~~
  589. ./tool/lemon.c:605:6: note: declared here
  590. 605 | void FindFirstSets(lemp)
  591. | ^~~~~~~~~~~~~
  592. ./tool/lemon.c:1407:5: error: too many arguments to function ‘FindStates’; expected 0, have 1
  593. 1407 | FindStates(&lem);
  594. | ^~~~~~~~~~ ~~~~
  595. ./tool/lemon.c:662:6: note: declared here
  596. 662 | void FindStates(lemp)
  597. | ^~~~~~~~~~
  598. ./tool/lemon.c:1411:5: error: too many arguments to function ‘FindLinks’; expected 0, have 1
  599. 1411 | FindLinks(&lem);
  600. | ^~~~~~~~~ ~~~~
  601. ./tool/lemon.c:814:6: note: declared here
  602. 814 | void FindLinks(lemp)
  603. | ^~~~~~~~~
  604. ./tool/lemon.c:1414:5: error: too many arguments to function ‘FindFollowSets’; expected 0, have 1
  605. 1414 | FindFollowSets(&lem);
  606. | ^~~~~~~~~~~~~~ ~~~~
  607. ./tool/lemon.c:850:6: note: declared here
  608. 850 | void FindFollowSets(lemp)
  609. | ^~~~~~~~~~~~~~
  610. ./tool/lemon.c:1417:5: error: too many arguments to function ‘FindActions’; expected 0, have 1
  611. 1417 | FindActions(&lem);
  612. | ^~~~~~~~~~~ ~~~~
  613. ./tool/lemon.c:887:6: note: declared here
  614. 887 | void FindActions(lemp)
  615. | ^~~~~~~~~~~
  616. ./tool/lemon.c:1420:23: error: too many arguments to function ‘CompressTables’; expected 0, have 1
  617. 1420 | if( compress==0 ) CompressTables(&lem);
  618. | ^~~~~~~~~~~~~~ ~~~~
  619. ./tool/lemon.c:97:6: note: declared here
  620. 97 | void CompressTables(/* struct lemon * */);
  621. | ^~~~~~~~~~~~~~
  622. ./tool/lemon.c:1423:18: error: too many arguments to function ‘ReportOutput’; expected 0, have 1
  623. 1423 | if( !quiet ) ReportOutput(&lem);
  624. | ^~~~~~~~~~~~ ~~~~
  625. ./tool/lemon.c:94:6: note: declared here
  626. 94 | void ReportOutput(/* struct lemon * */);
  627. | ^~~~~~~~~~~~
  628. ./tool/lemon.c:1426:5: error: too many arguments to function ‘ReportTable’; expected 0, have 2
  629. 1426 | ReportTable(&lem, mhflag);
  630. | ^~~~~~~~~~~ ~~~~
  631. ./tool/lemon.c:95:6: note: declared here
  632. 95 | void ReportTable(/* struct lemon * */);
  633. | ^~~~~~~~~~~
  634. ./tool/lemon.c:1431:19: error: too many arguments to function ‘ReportHeader’; expected 0, have 1
  635. 1431 | if( !mhflag ) ReportHeader(&lem);
  636. | ^~~~~~~~~~~~ ~~~~
  637. ./tool/lemon.c:96:6: note: declared here
  638. 96 | void ReportHeader(/* struct lemon * */);
  639. | ^~~~~~~~~~~~
  640. ./tool/lemon.c: In function ‘merge’:
  641. ./tool/lemon.c:1489:14: warning: old-style function definition [-Wold-style-definition]
  642. 1489 | static char *merge(a,b,cmp,offset)
  643. | ^~~~~
  644. ./tool/lemon.c:1502:10: error: too many arguments to function ‘cmp’; expected 0, have 2
  645. 1502 | if( (*cmp)(a,b)<0 ){
  646. | ~^~~~~ ~
  647. ./tool/lemon.c:1511:12: error: too many arguments to function ‘cmp’; expected 0, have 2
  648. 1511 | if( (*cmp)(a,b)<0 ){
  649. | ~^~~~~ ~
  650. ./tool/lemon.c: In function ‘msort’:
  651. ./tool/lemon.c:1541:7: warning: old-style function definition [-Wold-style-definition]
  652. 1541 | char *msort(list,next,cmp)
  653. | ^~~~~
  654. ./tool/lemon.c:1545:1: error: number of arguments doesn’t match prototype
  655. 1545 | {
  656. | ^
  657. ./tool/lemon.c:31:7: error: prototype declaration
  658. 31 | char *msort();
  659. | ^~~~~
  660. ./tool/lemon.c: In function ‘errline’:
  661. ./tool/lemon.c:1577:13: warning: old-style function definition [-Wold-style-definition]
  662. 1577 | static void errline(n,k,err)
  663. | ^~~~~~~
  664. ./tool/lemon.c: In function ‘argindex’:
  665. ./tool/lemon.c:1603:12: warning: old-style function definition [-Wold-style-definition]
  666. 1603 | static int argindex(n)
  667. | ^~~~~~~~
  668. ./tool/lemon.c: In function ‘handleflags’:
  669. ./tool/lemon.c:1625:12: warning: old-style function definition [-Wold-style-definition]
  670. 1625 | static int handleflags(i,err)
  671. | ^~~~~~~~~~~
  672. ./tool/lemon.c:1645:6: error: too many arguments to function ‘(void (*)(void))(op + (sizetype)((long unsigned int)j * 32))->arg’; expected 0, have 1
  673. 1645 | (*(void(*)())(op[j].arg))(v);
  674. | ~^~~~~~~~~~~~~~~~~~~~~~~~ ~
  675. ./tool/lemon.c: In function ‘handleswitch’:
  676. ./tool/lemon.c:1659:12: warning: old-style function definition [-Wold-style-definition]
  677. 1659 | static int handleswitch(i,err)
  678. | ^~~~~~~~~~~~
  679. ./tool/lemon.c:1727:10: error: too many arguments to function ‘(void (*)(void))(op + (sizetype)((long unsigned int)j * 32))->arg’; expected 0, have 1
  680. 1727 | (*(void(*)())(op[j].arg))(dv);
  681. | ~^~~~~~~~~~~~~~~~~~~~~~~~ ~~
  682. ./tool/lemon.c:1733:10: error: too many arguments to function ‘(void (*)(void))(op + (sizetype)((long unsigned int)j * 32))->arg’; expected 0, have 1
  683. 1733 | (*(void(*)())(op[j].arg))((int)lv);
  684. | ~^~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~
  685. ./tool/lemon.c:1739:10: error: too many arguments to function ‘(void (*)(void))(op + (sizetype)((long unsigned int)j * 32))->arg’; expected 0, have 1
  686. 1739 | (*(void(*)())(op[j].arg))(sv);
  687. | ~^~~~~~~~~~~~~~~~~~~~~~~~ ~~
  688. ./tool/lemon.c: In function ‘OptInit’:
  689. ./tool/lemon.c:1746:5: warning: old-style function definition [-Wold-style-definition]
  690. 1746 | int OptInit(a,o,err)
  691. | ^~~~~~~
  692. ./tool/lemon.c:1750:1: error: number of arguments doesn’t match prototype
  693. 1750 | {
  694. | ^
  695. ./tool/lemon.c:77:8: error: prototype declaration
  696. 77 | int OptInit(/* char**,struct s_options*,FILE* */);
  697. | ^~~~~~~
  698. ./tool/lemon.c: In function ‘OptArg’:
  699. ./tool/lemon.c:1786:7: warning: old-style function definition [-Wold-style-definition]
  700. 1786 | char *OptArg(n)
  701. | ^~~~~~
  702. ./tool/lemon.c:1788:1: error: number of arguments doesn’t match prototype
  703. 1788 | {
  704. | ^
  705. ./tool/lemon.c:79:8: error: prototype declaration
  706. 79 | char *OptArg(/* int */);
  707. | ^~~~~~
  708. ./tool/lemon.c: In function ‘OptErr’:
  709. ./tool/lemon.c:1794:6: warning: old-style function definition [-Wold-style-definition]
  710. 1794 | void OptErr(n)
  711. | ^~~~~~
  712. ./tool/lemon.c:1796:1: error: number of arguments doesn’t match prototype
  713. 1796 | {
  714. | ^
  715. ./tool/lemon.c:80:8: error: prototype declaration
  716. 80 | void OptErr(/* int */);
  717. | ^~~~~~
  718. ./tool/lemon.c: In function ‘parseonetoken’:
  719. ./tool/lemon.c:1901:13: warning: old-style function definition [-Wold-style-definition]
  720. 1901 | static void parseonetoken(psp)
  721. | ^~~~~~~~~~~~~
  722. ./tool/lemon.c:1905:7: error: too many arguments to function ‘Strsafe’; expected 0, have 1
  723. 1905 | x = Strsafe(psp->tokenstart); /* Save the token permanently */
  724. | ^~~~~~~ ~~~~~~~~~~~~~~~
  725. ./tool/lemon.c:292:7: note: declared here
  726. 292 | char *Strsafe();
  727. | ^~~~~~~
  728. ./tool/lemon.c:1921:20: error: too many arguments to function ‘Symbol_new’; expected 0, have 1
  729. 1921 | psp->lhs = Symbol_new(x);
  730. | ^~~~~~~~~~ ~
  731. ./tool/lemon.c:300:16: note: declared here
  732. 300 | struct symbol *Symbol_new();
  733. | ^~~~~~~~~~
  734. ./tool/lemon.c:1964:34: error: too many arguments to function ‘Symbol_new’; expected 0, have 1
  735. 1964 | psp->prevrule->precsym = Symbol_new(x);
  736. | ^~~~~~~~~~ ~
  737. ./tool/lemon.c:300:16: note: declared here
  738. 300 | struct symbol *Symbol_new();
  739. | ^~~~~~~~~~
  740. ./tool/lemon.c:2025:29: error: too many arguments to function ‘malloc’; expected 0, have 1
  741. 2025 | rp = (struct rule *)malloc( sizeof(struct rule) +
  742. | ^~~~~~ ~~~~~~~~~~~~~~~~~~~~~
  743. 2026 | sizeof(struct symbol*)*psp->nrhs + sizeof(char*)*psp->nrhs );
  744. | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  745. ./tool/lemon.c:32:14: note: declared here
  746. 32 | extern void *malloc();
  747. | ^~~~~~
  748. ./tool/lemon.c:2067:33: error: too many arguments to function ‘Symbol_new’; expected 0, have 1
  749. 2067 | psp->rhs[psp->nrhs] = Symbol_new(x);
  750. | ^~~~~~~~~~ ~
  751. ./tool/lemon.c:300:16: note: declared here
  752. 300 | struct symbol *Symbol_new();
  753. | ^~~~~~~~~~
  754. ./tool/lemon.c:2185:29: error: too many arguments to function ‘Symbol_new’; expected 0, have 1
  755. 2185 | struct symbol *sp = Symbol_new(x);
  756. | ^~~~~~~~~~ ~
  757. ./tool/lemon.c:300:16: note: declared here
  758. 300 | struct symbol *Symbol_new();
  759. | ^~~~~~~~~~
  760. ./tool/lemon.c:2198:29: error: too many arguments to function ‘Symbol_new’; expected 0, have 1
  761. 2198 | struct symbol *sp = Symbol_new(x);
  762. | ^~~~~~~~~~ ~
  763. ./tool/lemon.c:300:16: note: declared here
  764. 300 | struct symbol *Symbol_new();
  765. | ^~~~~~~~~~
  766. ./tool/lemon.c:2209:14: error: too many arguments to function ‘Symbol_new’; expected 0, have 1
  767. 2209 | sp = Symbol_new(x);
  768. | ^~~~~~~~~~ ~
  769. ./tool/lemon.c:300:16: note: declared here
  770. 300 | struct symbol *Symbol_new();
  771. | ^~~~~~~~~~
  772. ./tool/lemon.c:2252:29: error: too many arguments to function ‘Symbol_new’; expected 0, have 1
  773. 2252 | struct symbol *sp = Symbol_new(x);
  774. | ^~~~~~~~~~ ~
  775. ./tool/lemon.c:300:16: note: declared here
  776. 300 | struct symbol *Symbol_new();
  777. | ^~~~~~~~~~
  778. ./tool/lemon.c: In function ‘Parse’:
  779. ./tool/lemon.c:2280:6: warning: old-style function definition [-Wold-style-definition]
  780. 2280 | void Parse(gp)
  781. | ^~~~~
  782. ./tool/lemon.c:2282:1: error: number of arguments doesn’t match prototype
  783. 2282 | {
  784. | ^
  785. ./tool/lemon.c:84:6: error: prototype declaration
  786. 84 | void Parse(/* struct lemon *lemp */);
  787. | ^~~~~
  788. ./tool/lemon.c:2307:21: error: too many arguments to function ‘malloc’; expected 0, have 1
  789. 2307 | filebuf = (char *)malloc( filesize+1 );
  790. | ^~~~~~ ~~~~~~~~~~
  791. ./tool/lemon.c:32:14: note: declared here
  792. 32 | extern void *malloc();
  793. | ^~~~~~
  794. ./tool/lemon.c: In function ‘Plink_new’:
  795. ./tool/lemon.c:2432:38: error: too many arguments to function ‘malloc’; expected 0, have 1
  796. 2432 | plink_freelist = (struct plink *)malloc( sizeof(struct plink)*amt );
  797. | ^~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~
  798. ./tool/lemon.c:32:14: note: declared here
  799. 32 | extern void *malloc();
  800. | ^~~~~~
  801. ./tool/lemon.c: In function ‘Plink_add’:
  802. ./tool/lemon.c:2447:6: warning: old-style function definition [-Wold-style-definition]
  803. 2447 | void Plink_add(plpp,cfp)
  804. | ^~~~~~~~~
  805. ./tool/lemon.c:2450:1: error: number of arguments doesn’t match prototype
  806. 2450 | {
  807. | ^
  808. ./tool/lemon.c:88:6: error: prototype declaration
  809. 88 | void Plink_add(/* struct plink **, struct config * */);
  810. | ^~~~~~~~~
  811. ./tool/lemon.c: In function ‘Plink_copy’:
  812. ./tool/lemon.c:2459:6: warning: old-style function definition [-Wold-style-definition]
  813. 2459 | void Plink_copy(to,from)
  814. | ^~~~~~~~~~
  815. ./tool/lemon.c:2462:1: error: number of arguments doesn’t match prototype
  816. 2462 | {
  817. | ^
  818. ./tool/lemon.c:89:6: error: prototype declaration
  819. 89 | void Plink_copy(/* struct plink **, struct plink * */);
  820. | ^~~~~~~~~~
  821. ./tool/lemon.c: In function ‘Plink_delete’:
  822. ./tool/lemon.c:2473:6: warning: old-style function definition [-Wold-style-definition]
  823. 2473 | void Plink_delete(plp)
  824. | ^~~~~~~~~~~~
  825. ./tool/lemon.c:2475:1: error: number of arguments doesn’t match prototype
  826. 2475 | {
  827. | ^
  828. ./tool/lemon.c:90:6: error: prototype declaration
  829. 90 | void Plink_delete(/* struct plink * */);
  830. | ^~~~~~~~~~~~
  831. ./tool/lemon.c: In function ‘file_makename’:
  832. ./tool/lemon.c:2494:15: warning: old-style function definition [-Wold-style-definition]
  833. 2494 | PRIVATE char *file_makename(lemp,suffix)
  834. | ^~~~~~~~~~~~~
  835. ./tool/lemon.c:2501:10: error: too many arguments to function ‘malloc’; expected 0, have 1
  836. 2501 | name = malloc( strlen(lemp->filename) + strlen(suffix) + 5 );
  837. | ^~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  838. ./tool/lemon.c:32:14: note: declared here
  839. 32 | extern void *malloc();
  840. | ^~~~~~
  841. ./tool/lemon.c: In function ‘file_open’:
  842. ./tool/lemon.c:2516:15: warning: old-style function definition [-Wold-style-definition]
  843. 2516 | PRIVATE FILE *file_open(lemp,suffix,mode)
  844. | ^~~~~~~~~
  845. ./tool/lemon.c: In function ‘Reprint’:
  846. ./tool/lemon.c:2536:6: warning: old-style function definition [-Wold-style-definition]
  847. 2536 | void Reprint(lemp)
  848. | ^~~~~~~
  849. ./tool/lemon.c:2538:1: error: number of arguments doesn’t match prototype
  850. 2538 | {
  851. | ^
  852. ./tool/lemon.c:93:6: error: prototype declaration
  853. 93 | void Reprint(/* struct lemon * */);
  854. | ^~~~~~~
  855. ./tool/lemon.c:41:29: error: too many arguments to function ‘myassert’; expected 0, have 2
  856. 41 | # define assert(X) if(!(X))myassert(__FILE__,__LINE__)
  857. | ^~~~~~~~
  858. ./tool/lemon.c:2556:7: note: in expansion of macro ‘assert’
  859. 2556 | assert( sp->index==j );
  860. | ^~~~~~
  861. ./tool/lemon.c:560:6: note: declared here
  862. 560 | void myassert(file,line)
  863. | ^~~~~~~~
  864. ./tool/lemon.c: In function ‘ConfigPrint’:
  865. ./tool/lemon.c:2576:6: warning: old-style function definition [-Wold-style-definition]
  866. 2576 | void ConfigPrint(fp,cfp)
  867. | ^~~~~~~~~~~
  868. ./tool/lemon.c: In function ‘ReportOutput’:
  869. ./tool/lemon.c:2659:6: warning: old-style function definition [-Wold-style-definition]
  870. 2659 | void ReportOutput(lemp)
  871. | ^~~~~~~~~~~~
  872. ./tool/lemon.c:2661:1: error: number of arguments doesn’t match prototype
  873. 2661 | {
  874. | ^
  875. ./tool/lemon.c:94:6: error: prototype declaration
  876. 94 | void ReportOutput(/* struct lemon * */);
  877. | ^~~~~~~~~~~~
  878. ./tool/lemon.c: In function ‘pathsearch’:
  879. ./tool/lemon.c:2706:15: warning: old-style function definition [-Wold-style-definition]
  880. 2706 | PRIVATE char *pathsearch(argv0,name,modemask)
  881. | ^~~~~~~~~~
  882. ./tool/lemon.c:2714:14: error: conflicting types for ‘access’; have ‘int(void)’
  883. 2714 | extern int access();
  884. | ^~~~~~
  885. In file included from ./tool/lemon.c:14:
  886. /usr/include/unistd.h:287:12: note: previous declaration of ‘access’ with type ‘int(const char *, int)’
  887. 287 | extern int access (const char *__name, int __type) __THROW __nonnull ((1));
  888. | ^~~~~~
  889. ./tool/lemon.c:2724:20: error: too many arguments to function ‘malloc’; expected 0, have 1
  890. 2724 | path = (char *)malloc( strlen(argv0) + strlen(name) + 2 );
  891. | ^~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  892. ./tool/lemon.c:32:14: note: declared here
  893. 32 | extern void *malloc();
  894. | ^~~~~~
  895. ./tool/lemon.c:2728:18: error: conflicting types for ‘getenv’; have ‘char *(void)’
  896. 2728 | extern char *getenv();
  897. | ^~~~~~
  898. /usr/include/stdlib.h:773:14: note: previous declaration of ‘getenv’ with type ‘char *(const char *)’
  899. 773 | extern char *getenv (const char *__name) __THROW __nonnull ((1)) __wur;
  900. | ^~~~~~
  901. ./tool/lemon.c:2729:16: error: too many arguments to function ‘getenv’; expected 0, have 1
  902. 2729 | pathlist = getenv("PATH");
  903. | ^~~~~~ ~~~~~~
  904. ./tool/lemon.c:2728:18: note: declared here
  905. 2728 | extern char *getenv();
  906. | ^~~~~~
  907. ./tool/lemon.c:2731:20: error: too many arguments to function ‘malloc’; expected 0, have 1
  908. 2731 | path = (char *)malloc( strlen(pathlist)+strlen(name)+2 );
  909. | ^~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  910. ./tool/lemon.c:32:14: note: declared here
  911. 32 | extern void *malloc();
  912. | ^~~~~~
  913. ./tool/lemon.c:2742:13: error: too many arguments to function ‘access’; expected 0, have 2
  914. 2742 | if( access(path,modemask)==0 ) break;
  915. | ^~~~~~ ~~~~
  916. ./tool/lemon.c:2714:14: note: declared here
  917. 2714 | extern int access();
  918. | ^~~~~~
  919. ./tool/lemon.c: In function ‘compute_action’:
  920. ./tool/lemon.c:2753:13: warning: old-style function definition [-Wold-style-definition]
  921. 2753 | PRIVATE int compute_action(lemp,ap)
  922. | ^~~~~~~~~~~~~~
  923. ./tool/lemon.c: In function ‘tplt_xfer’:
  924. ./tool/lemon.c:2778:14: warning: old-style function definition [-Wold-style-definition]
  925. 2778 | PRIVATE void tplt_xfer(name,in,out,lineno)
  926. | ^~~~~~~~~
  927. ./tool/lemon.c: In function ‘tplt_open’:
  928. ./tool/lemon.c:2807:15: warning: old-style function definition [-Wold-style-definition]
  929. 2807 | PRIVATE FILE *tplt_open(lemp)
  930. | ^~~~~~~~~
  931. ./tool/lemon.c: In function ‘tplt_print’:
  932. ./tool/lemon.c:2845:14: warning: old-style function definition [-Wold-style-definition]
  933. 2845 | PRIVATE void tplt_print(out,lemp,str,strln,lineno)
  934. | ^~~~~~~~~~
  935. ./tool/lemon.c: In function ‘emit_destructor_code’:
  936. ./tool/lemon.c:2867:6: warning: old-style function definition [-Wold-style-definition]
  937. 2867 | void emit_destructor_code(out,sp,lemp,lineno)
  938. | ^~~~~~~~~~~~~~~~~~~~
  939. ./tool/lemon.c:41:29: error: too many arguments to function ‘myassert’; expected 0, have 2
  940. 41 | # define assert(X) if(!(X))myassert(__FILE__,__LINE__)
  941. | ^~~~~~~~
  942. ./tool/lemon.c:2888:4: note: in expansion of macro ‘assert’
  943. 2888 | assert( 0 ); /* Cannot happen */
  944. | ^~~~~~
  945. ./tool/lemon.c:560:6: note: declared here
  946. 560 | void myassert(file,line)
  947. | ^~~~~~~~
  948. ./tool/lemon.c: In function ‘has_destructor’:
  949. ./tool/lemon.c:2907:5: warning: old-style function definition [-Wold-style-definition]
  950. 2907 | int has_destructor(sp, lemp)
  951. | ^~~~~~~~~~~~~~
  952. ./tool/lemon.c: In function ‘emit_code’:
  953. ./tool/lemon.c:2924:14: warning: old-style function definition [-Wold-style-definition]
  954. 2924 | PRIVATE void emit_code(out,rp,lemp,lineno)
  955. | ^~~~~~~~~
  956. ./tool/lemon.c: In function ‘print_stack_union’:
  957. ./tool/lemon.c:3008:6: warning: old-style function definition [-Wold-style-definition]
  958. 3008 | void print_stack_union(out,lemp,plineno,mhflag)
  959. | ^~~~~~~~~~~~~~~~~
  960. ./tool/lemon.c:3025:19: error: too many arguments to function ‘malloc’; expected 0, have 1
  961. 3025 | types = (char**)malloc( arraysize * sizeof(char*) );
  962. | ^~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~
  963. ./tool/lemon.c:32:14: note: declared here
  964. 32 | extern void *malloc();
  965. | ^~~~~~
  966. ./tool/lemon.c:3038:18: error: too many arguments to function ‘malloc’; expected 0, have 1
  967. 3038 | stddt = (char*)malloc( maxdtlength*2 + 1 );
  968. | ^~~~~~ ~~~~~~~~~~~~~~~~~
  969. ./tool/lemon.c:32:14: note: declared here
  970. 32 | extern void *malloc();
  971. | ^~~~~~
  972. ./tool/lemon.c:3083:28: error: too many arguments to function ‘malloc’; expected 0, have 1
  973. 3083 | types[hash] = (char*)malloc( strlen(stddt)+1 );
  974. | ^~~~~~ ~~~~~~~~~~~~~~~
  975. ./tool/lemon.c:32:14: note: declared here
  976. 32 | extern void *malloc();
  977. | ^~~~~~
  978. ./tool/lemon.c: In function ‘ReportTable’:
  979. ./tool/lemon.c:3157:6: warning: old-style function definition [-Wold-style-definition]
  980. 3157 | void ReportTable(lemp, mhflag)
  981. | ^~~~~~~~~~~
  982. ./tool/lemon.c:3160:1: error: number of arguments doesn’t match prototype
  983. 3160 | {
  984. | ^
  985. ./tool/lemon.c:95:6: error: prototype declaration
  986. 95 | void ReportTable(/* struct lemon * */);
  987. | ^~~~~~~~~~~
  988. ./tool/lemon.c:3273:8: error: too many arguments to function ‘malloc’; expected 0, have 1
  989. 3273 | ax = malloc( sizeof(ax[0])*lemp->nstate*2 );
  990. | ^~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  991. ./tool/lemon.c:32:14: note: declared here
  992. 32 | extern void *malloc();
  993. | ^~~~~~
  994. ./tool/lemon.c:41:29: error: too many arguments to function ‘myassert’; expected 0, have 2
  995. 41 | # define assert(X) if(!(X))myassert(__FILE__,__LINE__)
  996. | ^~~~~~~~
  997. ./tool/lemon.c:3463:5: note: in expansion of macro ‘assert’
  998. 3463 | assert( rp->index==i );
  999. | ^~~~~~
  1000. ./tool/lemon.c:560:6: note: declared here
  1001. 560 | void myassert(file,line)
  1002. | ^~~~~~~~
  1003. ./tool/lemon.c: In function ‘ReportHeader’:
  1004. ./tool/lemon.c:3552:6: warning: old-style function definition [-Wold-style-definition]
  1005. 3552 | void ReportHeader(lemp)
  1006. | ^~~~~~~~~~~~
  1007. ./tool/lemon.c:3554:1: error: number of arguments doesn’t match prototype
  1008. 3554 | {
  1009. | ^
  1010. ./tool/lemon.c:96:6: error: prototype declaration
  1011. 96 | void ReportHeader(/* struct lemon * */);
  1012. | ^~~~~~~~~~~~
  1013. ./tool/lemon.c: In function ‘CompressTables’:
  1014. ./tool/lemon.c:3591:6: warning: old-style function definition [-Wold-style-definition]
  1015. 3591 | void CompressTables(lemp)
  1016. | ^~~~~~~~~~~~~~
  1017. ./tool/lemon.c:3593:1: error: number of arguments doesn’t match prototype
  1018. 3593 | {
  1019. | ^
  1020. ./tool/lemon.c:97:6: error: prototype declaration
  1021. 97 | void CompressTables(/* struct lemon * */);
  1022. | ^~~~~~~~~~~~~~
  1023. ./tool/lemon.c:41:29: error: too many arguments to function ‘myassert’; expected 0, have 2
  1024. 41 | # define assert(X) if(!(X))myassert(__FILE__,__LINE__)
  1025. | ^~~~~~~~
  1026. ./tool/lemon.c:3631:5: note: in expansion of macro ‘assert’
  1027. 3631 | assert( ap );
  1028. | ^~~~~~
  1029. ./tool/lemon.c:560:6: note: declared here
  1030. 560 | void myassert(file,line)
  1031. | ^~~~~~~~
  1032. ./tool/lemon.c:3632:14: error: too many arguments to function ‘Symbol_new’; expected 0, have 1
  1033. 3632 | ap->sp = Symbol_new("{default}");
  1034. | ^~~~~~~~~~ ~~~~~~~~~~~
  1035. ./tool/lemon.c:300:16: note: declared here
  1036. 300 | struct symbol *Symbol_new();
  1037. | ^~~~~~~~~~
  1038. ./tool/lemon.c:3636:15: error: too many arguments to function ‘Action_sort’; expected 0, have 1
  1039. 3636 | stp->ap = Action_sort(stp->ap);
  1040. | ^~~~~~~~~~~ ~~~~~~~
  1041. ./tool/lemon.c:367:16: note: declared here
  1042. 367 | struct action *Action_sort(ap)
  1043. | ^~~~~~~~~~~
  1044. ./tool/lemon.c: In function ‘SetSize’:
  1045. ./tool/lemon.c:3648:6: warning: old-style function definition [-Wold-style-definition]
  1046. 3648 | void SetSize(n)
  1047. | ^~~~~~~
  1048. ./tool/lemon.c:3650:1: error: number of arguments doesn’t match prototype
  1049. 3650 | {
  1050. | ^
  1051. ./tool/lemon.c:100:7: error: prototype declaration
  1052. 100 | void SetSize(/* int N */); /* All sets will be of size N */
  1053. | ^~~~~~~
  1054. ./tool/lemon.c: In function ‘SetNew’:
  1055. ./tool/lemon.c:3658:14: error: too many arguments to function ‘malloc’; expected 0, have 1
  1056. 3658 | s = (char*)malloc( size );
  1057. | ^~~~~~ ~~~~
  1058. ./tool/lemon.c:32:14: note: declared here
  1059. 32 | extern void *malloc();
  1060. | ^~~~~~
  1061. ./tool/lemon.c: In function ‘SetFree’:
  1062. ./tool/lemon.c:3668:6: warning: old-style function definition [-Wold-style-definition]
  1063. 3668 | void SetFree(s)
  1064. | ^~~~~~~
  1065. ./tool/lemon.c:3670:1: error: number of arguments doesn’t match prototype
  1066. 3670 | {
  1067. | ^
  1068. ./tool/lemon.c:102:7: error: prototype declaration
  1069. 102 | void SetFree(/* char* */); /* Deallocate a set */
  1070. | ^~~~~~~
  1071. ./tool/lemon.c: In function ‘SetAdd’:
  1072. ./tool/lemon.c:3676:5: warning: old-style function definition [-Wold-style-definition]
  1073. 3676 | int SetAdd(s,e)
  1074. | ^~~~~~
  1075. ./tool/lemon.c:3679:1: error: number of arguments doesn’t match prototype
  1076. 3679 | {
  1077. | ^
  1078. ./tool/lemon.c:104:5: error: prototype declaration
  1079. 104 | int SetAdd(/* char*,int */); /* Add element to a set */
  1080. | ^~~~~~
  1081. ./tool/lemon.c: In function ‘SetUnion’:
  1082. ./tool/lemon.c:3687:5: warning: old-style function definition [-Wold-style-definition]
  1083. 3687 | int SetUnion(s1,s2)
  1084. | ^~~~~~~~
  1085. ./tool/lemon.c:3690:1: error: number of arguments doesn’t match prototype
  1086. 3690 | {
  1087. | ^
  1088. ./tool/lemon.c:105:5: error: prototype declaration
  1089. 105 | int SetUnion(/* char *A,char *B */); /* A <- A U B, thru element N */
  1090. | ^~~~~~~~
  1091. ./tool/lemon.c: In function ‘strhash’:
  1092. ./tool/lemon.c:3715:13: warning: old-style function definition [-Wold-style-definition]
  1093. 3715 | PRIVATE int strhash(x)
  1094. | ^~~~~~~
  1095. ./tool/lemon.c: In function ‘Strsafe’:
  1096. ./tool/lemon.c:3727:7: warning: old-style function definition [-Wold-style-definition]
  1097. 3727 | char *Strsafe(y)
  1098. | ^~~~~~~
  1099. ./tool/lemon.c:3729:1: error: number of arguments doesn’t match prototype
  1100. 3729 | {
  1101. | ^
  1102. ./tool/lemon.c:292:7: error: prototype declaration
  1103. 292 | char *Strsafe();
  1104. | ^~~~~~~
  1105. ./tool/lemon.c:3732:7: error: too many arguments to function ‘Strsafe_find’; expected 0, have 1
  1106. 3732 | z = Strsafe_find(y);
  1107. | ^~~~~~~~~~~~ ~
  1108. ./tool/lemon.c:296:7: note: declared here
  1109. 296 | char *Strsafe_find(/* char * */);
  1110. | ^~~~~~~~~~~~
  1111. ./tool/lemon.c:3733:18: error: too many arguments to function ‘malloc’; expected 0, have 1
  1112. 3733 | if( z==0 && (z=malloc( strlen(y)+1 ))!=0 ){
  1113. | ^~~~~~ ~~~~~~~~~~~
  1114. ./tool/lemon.c:32:14: note: declared here
  1115. 32 | extern void *malloc();
  1116. | ^~~~~~
  1117. ./tool/lemon.c:3735:5: error: too many arguments to function ‘Strsafe_insert’; expected 0, have 1
  1118. 3735 | Strsafe_insert(z);
  1119. | ^~~~~~~~~~~~~~ ~
  1120. ./tool/lemon.c:295:5: note: declared here
  1121. 295 | int Strsafe_insert(/* char * */);
  1122. | ^~~~~~~~~~~~~~
  1123. ./tool/lemon.c: In function ‘Strsafe_init’:
  1124. ./tool/lemon.c:3768:23: error: too many arguments to function ‘malloc’; expected 0, have 1
  1125. 3768 | x1a = (struct s_x1*)malloc( sizeof(struct s_x1) );
  1126. | ^~~~~~ ~~~~~~~~~~~~~~~~~~~
  1127. ./tool/lemon.c:32:14: note: declared here
  1128. 32 | extern void *malloc();
  1129. | ^~~~~~
  1130. ./tool/lemon.c:3772:25: error: too many arguments to function ‘malloc’; expected 0, have 1
  1131. 3772 | x1a->tbl = (x1node*)malloc(
  1132. | ^~~~~~
  1133. 3773 | (sizeof(x1node) + sizeof(x1node*))*1024 );
  1134. | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  1135. ./tool/lemon.c:32:14: note: declared here
  1136. 32 | extern void *malloc();
  1137. | ^~~~~~
  1138. ./tool/lemon.c: In function ‘Strsafe_insert’:
  1139. ./tool/lemon.c:3786:5: warning: old-style function definition [-Wold-style-definition]
  1140. 3786 | int Strsafe_insert(data)
  1141. | ^~~~~~~~~~~~~~
  1142. ./tool/lemon.c:3788:1: error: number of arguments doesn’t match prototype
  1143. 3788 | {
  1144. | ^
  1145. ./tool/lemon.c:295:5: error: prototype declaration
  1146. 295 | int Strsafe_insert(/* char * */);
  1147. | ^~~~~~~~~~~~~~
  1148. ./tool/lemon.c:3811:26: error: too many arguments to function ‘malloc’; expected 0, have 1
  1149. 3811 | array.tbl = (x1node*)malloc(
  1150. | ^~~~~~
  1151. 3812 | (sizeof(x1node) + sizeof(x1node*))*size );
  1152. | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  1153. ./tool/lemon.c:32:14: note: declared here
  1154. 32 | extern void *malloc();
  1155. | ^~~~~~
  1156. ./tool/lemon.c: In function ‘Strsafe_find’:
  1157. ./tool/lemon.c:3843:7: warning: old-style function definition [-Wold-style-definition]
  1158. 3843 | char *Strsafe_find(key)
  1159. | ^~~~~~~~~~~~
  1160. ./tool/lemon.c:3845:1: error: number of arguments doesn’t match prototype
  1161. 3845 | {
  1162. | ^
  1163. ./tool/lemon.c:296:7: error: prototype declaration
  1164. 296 | char *Strsafe_find(/* char * */);
  1165. | ^~~~~~~~~~~~
  1166. ./tool/lemon.c: In function ‘Symbol_new’:
  1167. ./tool/lemon.c:3862:16: warning: old-style function definition [-Wold-style-definition]
  1168. 3862 | struct symbol *Symbol_new(x)
  1169. | ^~~~~~~~~~
  1170. ./tool/lemon.c:3864:1: error: number of arguments doesn’t match prototype
  1171. 3864 | {
  1172. | ^
  1173. ./tool/lemon.c:300:16: error: prototype declaration
  1174. 300 | struct symbol *Symbol_new();
  1175. | ^~~~~~~~~~
  1176. ./tool/lemon.c:3867:8: error: too many arguments to function ‘Symbol_find’; expected 0, have 1
  1177. 3867 | sp = Symbol_find(x);
  1178. | ^~~~~~~~~~~ ~
  1179. ./tool/lemon.c:304:16: note: declared here
  1180. 304 | struct symbol *Symbol_find(/* char * */);
  1181. | ^~~~~~~~~~~
  1182. ./tool/lemon.c:3869:27: error: too many arguments to function ‘malloc’; expected 0, have 1
  1183. 3869 | sp = (struct symbol *)malloc( sizeof(struct symbol) );
  1184. | ^~~~~~ ~~~~~~~~~~~~~~~~~~~~~
  1185. ./tool/lemon.c:32:14: note: declared here
  1186. 32 | extern void *malloc();
  1187. | ^~~~~~
  1188. ./tool/lemon.c:3871:16: error: too many arguments to function ‘Strsafe’; expected 0, have 1
  1189. 3871 | sp->name = Strsafe(x);
  1190. | ^~~~~~~ ~
  1191. ./tool/lemon.c:3727:7: note: declared here
  1192. 3727 | char *Strsafe(y)
  1193. | ^~~~~~~
  1194. ./tool/lemon.c:3881:5: error: too many arguments to function ‘Symbol_insert’; expected 0, have 2
  1195. 3881 | Symbol_insert(sp,sp->name);
  1196. | ^~~~~~~~~~~~~ ~~
  1197. ./tool/lemon.c:303:5: note: declared here
  1198. 303 | int Symbol_insert(/* struct symbol *, char * */);
  1199. | ^~~~~~~~~~~~~
  1200. ./tool/lemon.c: At top level:
  1201. ./tool/lemon.c:3896:5: error: conflicting types for ‘Symbolcmpp’; have ‘int(struct symbol **, struct symbol **)’
  1202. 3896 | int Symbolcmpp(struct symbol **a, struct symbol **b){
  1203. | ^~~~~~~~~~
  1204. ./tool/lemon.c:301:5: note: previous declaration of ‘Symbolcmpp’ with type ‘int(void)’
  1205. 301 | int Symbolcmpp(/* struct symbol **, struct symbol ** */);
  1206. | ^~~~~~~~~~
  1207. ./tool/lemon.c: In function ‘Symbol_init’:
  1208. ./tool/lemon.c:3930:23: error: too many arguments to function ‘malloc’; expected 0, have 1
  1209. 3930 | x2a = (struct s_x2*)malloc( sizeof(struct s_x2) );
  1210. | ^~~~~~ ~~~~~~~~~~~~~~~~~~~
  1211. ./tool/lemon.c:32:14: note: declared here
  1212. 32 | extern void *malloc();
  1213. | ^~~~~~
  1214. ./tool/lemon.c:3934:25: error: too many arguments to function ‘malloc’; expected 0, have 1
  1215. 3934 | x2a->tbl = (x2node*)malloc(
  1216. | ^~~~~~
  1217. 3935 | (sizeof(x2node) + sizeof(x2node*))*128 );
  1218. | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  1219. ./tool/lemon.c:32:14: note: declared here
  1220. 32 | extern void *malloc();
  1221. | ^~~~~~
  1222. ./tool/lemon.c: In function ‘Symbol_insert’:
  1223. ./tool/lemon.c:3948:5: warning: old-style function definition [-Wold-style-definition]
  1224. 3948 | int Symbol_insert(data,key)
  1225. | ^~~~~~~~~~~~~
  1226. ./tool/lemon.c:3951:1: error: number of arguments doesn’t match prototype
  1227. 3951 | {
  1228. | ^
  1229. ./tool/lemon.c:303:5: error: prototype declaration
  1230. 303 | int Symbol_insert(/* struct symbol *, char * */);
  1231. | ^~~~~~~~~~~~~
  1232. ./tool/lemon.c:3974:26: error: too many arguments to function ‘malloc’; expected 0, have 1
  1233. 3974 | array.tbl = (x2node*)malloc(
  1234. | ^~~~~~
  1235. 3975 | (sizeof(x2node) + sizeof(x2node*))*size );
  1236. | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  1237. ./tool/lemon.c:32:14: note: declared here
  1238. 32 | extern void *malloc();
  1239. | ^~~~~~
  1240. ./tool/lemon.c: In function ‘Symbol_find’:
  1241. ./tool/lemon.c:4008:16: warning: old-style function definition [-Wold-style-definition]
  1242. 4008 | struct symbol *Symbol_find(key)
  1243. | ^~~~~~~~~~~
  1244. ./tool/lemon.c:4010:1: error: number of arguments doesn’t match prototype
  1245. 4010 | {
  1246. | ^
  1247. ./tool/lemon.c:304:16: error: prototype declaration
  1248. 304 | struct symbol *Symbol_find(/* char * */);
  1249. | ^~~~~~~~~~~
  1250. ./tool/lemon.c: In function ‘Symbol_Nth’:
  1251. ./tool/lemon.c:4025:16: warning: old-style function definition [-Wold-style-definition]
  1252. 4025 | struct symbol *Symbol_Nth(n)
  1253. | ^~~~~~~~~~
  1254. ./tool/lemon.c:4027:1: error: number of arguments doesn’t match prototype
  1255. 4027 | {
  1256. | ^
  1257. ./tool/lemon.c:305:16: error: prototype declaration
  1258. 305 | struct symbol *Symbol_Nth(/* int */);
  1259. | ^~~~~~~~~~
  1260. ./tool/lemon.c: In function ‘Symbol_arrayof’:
  1261. ./tool/lemon.c:4052:29: error: too many arguments to function ‘malloc’; expected 0, have 1
  1262. 4052 | array = (struct symbol **)malloc( sizeof(struct symbol *)*size );
  1263. | ^~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  1264. ./tool/lemon.c:32:14: note: declared here
  1265. 32 | extern void *malloc();
  1266. | ^~~~~~
  1267. ./tool/lemon.c: In function ‘Configcmp’:
  1268. ./tool/lemon.c:4060:5: warning: old-style function definition [-Wold-style-definition]
  1269. 4060 | int Configcmp(a,b)
  1270. | ^~~~~~~~~
  1271. ./tool/lemon.c:4063:1: error: number of arguments doesn’t match prototype
  1272. 4063 | {
  1273. | ^
  1274. ./tool/lemon.c:311:5: error: prototype declaration
  1275. 311 | int Configcmp(/* struct config *, struct config * */);
  1276. | ^~~~~~~~~
  1277. ./tool/lemon.c: In function ‘statecmp’:
  1278. ./tool/lemon.c:4071:13: warning: old-style function definition [-Wold-style-definition]
  1279. 4071 | PRIVATE int statecmp(a,b)
  1280. | ^~~~~~~~
  1281. ./tool/lemon.c: In function ‘statehash’:
  1282. ./tool/lemon.c:4088:13: warning: old-style function definition [-Wold-style-definition]
  1283. 4088 | PRIVATE int statehash(a)
  1284. | ^~~~~~~~~
  1285. ./tool/lemon.c: In function ‘State_new’:
  1286. ./tool/lemon.c:4103:25: error: too many arguments to function ‘malloc’; expected 0, have 1
  1287. 4103 | new = (struct state *)malloc( sizeof(struct state) );
  1288. | ^~~~~~ ~~~~~~~~~~~~~~~~~~~~
  1289. ./tool/lemon.c:32:14: note: declared here
  1290. 32 | extern void *malloc();
  1291. | ^~~~~~
  1292. ./tool/lemon.c: In function ‘State_init’:
  1293. ./tool/lemon.c:4136:23: error: too many arguments to function ‘malloc’; expected 0, have 1
  1294. 4136 | x3a = (struct s_x3*)malloc( sizeof(struct s_x3) );
  1295. | ^~~~~~ ~~~~~~~~~~~~~~~~~~~
  1296. ./tool/lemon.c:32:14: note: declared here
  1297. 32 | extern void *malloc();
  1298. | ^~~~~~
  1299. ./tool/lemon.c:4140:25: error: too many arguments to function ‘malloc’; expected 0, have 1
  1300. 4140 | x3a->tbl = (x3node*)malloc(
  1301. | ^~~~~~
  1302. 4141 | (sizeof(x3node) + sizeof(x3node*))*128 );
  1303. | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  1304. ./tool/lemon.c:32:14: note: declared here
  1305. 32 | extern void *malloc();
  1306. | ^~~~~~
  1307. ./tool/lemon.c: In function ‘State_insert’:
  1308. ./tool/lemon.c:4154:5: warning: old-style function definition [-Wold-style-definition]
  1309. 4154 | int State_insert(data,key)
  1310. | ^~~~~~~~~~~~
  1311. ./tool/lemon.c:4157:1: error: number of arguments doesn’t match prototype
  1312. 4157 | {
  1313. | ^
  1314. ./tool/lemon.c:314:5: error: prototype declaration
  1315. 314 | int State_insert(/* struct state *, struct config * */);
  1316. | ^~~~~~~~~~~~
  1317. ./tool/lemon.c:4180:26: error: too many arguments to function ‘malloc’; expected 0, have 1
  1318. 4180 | array.tbl = (x3node*)malloc(
  1319. | ^~~~~~
  1320. 4181 | (sizeof(x3node) + sizeof(x3node*))*size );
  1321. | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  1322. ./tool/lemon.c:32:14: note: declared here
  1323. 32 | extern void *malloc();
  1324. | ^~~~~~
  1325. ./tool/lemon.c: In function ‘State_find’:
  1326. ./tool/lemon.c:4214:15: warning: old-style function definition [-Wold-style-definition]
  1327. 4214 | struct state *State_find(key)
  1328. | ^~~~~~~~~~
  1329. ./tool/lemon.c:4216:1: error: number of arguments doesn’t match prototype
  1330. 4216 | {
  1331. | ^
  1332. ./tool/lemon.c:315:15: error: prototype declaration
  1333. 315 | struct state *State_find(/* struct config * */);
  1334. | ^~~~~~~~~~
  1335. ./tool/lemon.c: In function ‘State_arrayof’:
  1336. ./tool/lemon.c:4239:28: error: too many arguments to function ‘malloc’; expected 0, have 1
  1337. 4239 | array = (struct state **)malloc( sizeof(struct state *)*size );
  1338. | ^~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~
  1339. ./tool/lemon.c:32:14: note: declared here
  1340. 32 | extern void *malloc();
  1341. | ^~~~~~
  1342. ./tool/lemon.c: In function ‘confighash’:
  1343. ./tool/lemon.c:4247:13: warning: old-style function definition [-Wold-style-definition]
  1344. 4247 | PRIVATE int confighash(a)
  1345. | ^~~~~~~~~~
  1346. ./tool/lemon.c: In function ‘Configtable_init’:
  1347. ./tool/lemon.c:4282:23: error: too many arguments to function ‘malloc’; expected 0, have 1
  1348. 4282 | x4a = (struct s_x4*)malloc( sizeof(struct s_x4) );
  1349. | ^~~~~~ ~~~~~~~~~~~~~~~~~~~
  1350. ./tool/lemon.c:32:14: note: declared here
  1351. 32 | extern void *malloc();
  1352. | ^~~~~~
  1353. ./tool/lemon.c:4286:25: error: too many arguments to function ‘malloc’; expected 0, have 1
  1354. 4286 | x4a->tbl = (x4node*)malloc(
  1355. | ^~~~~~
  1356. 4287 | (sizeof(x4node) + sizeof(x4node*))*64 );
  1357. | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  1358. ./tool/lemon.c:32:14: note: declared here
  1359. 32 | extern void *malloc();
  1360. | ^~~~~~
  1361. ./tool/lemon.c: In function ‘Configtable_insert’:
  1362. ./tool/lemon.c:4300:5: warning: old-style function definition [-Wold-style-definition]
  1363. 4300 | int Configtable_insert(data)
  1364. | ^~~~~~~~~~~~~~~~~~
  1365. ./tool/lemon.c:4302:1: error: number of arguments doesn’t match prototype
  1366. 4302 | {
  1367. | ^
  1368. ./tool/lemon.c:321:5: error: prototype declaration
  1369. 321 | int Configtable_insert(/* struct config * */);
  1370. | ^~~~~~~~~~~~~~~~~~
  1371. ./tool/lemon.c:4312:9: error: too many arguments to function ‘Configcmp’; expected 0, have 2
  1372. 4312 | if( Configcmp(np->data,data)==0 ){
  1373. | ^~~~~~~~~ ~~~~~~~~
  1374. ./tool/lemon.c:4060:5: note: declared here
  1375. 4060 | int Configcmp(a,b)
  1376. | ^~~~~~~~~
  1377. ./tool/lemon.c:4325:26: error: too many arguments to function ‘malloc’; expected 0, have 1
  1378. 4325 | array.tbl = (x4node*)malloc(
  1379. | ^~~~~~
  1380. 4326 | (sizeof(x4node) + sizeof(x4node*))*size );
  1381. | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  1382. ./tool/lemon.c:32:14: note: declared here
  1383. 32 | extern void *malloc();
  1384. | ^~~~~~
  1385. ./tool/lemon.c: In function ‘Configtable_find’:
  1386. ./tool/lemon.c:4357:16: warning: old-style function definition [-Wold-style-definition]
  1387. 4357 | struct config *Configtable_find(key)
  1388. | ^~~~~~~~~~~~~~~~
  1389. ./tool/lemon.c:4359:1: error: number of arguments doesn’t match prototype
  1390. 4359 | {
  1391. | ^
  1392. ./tool/lemon.c:322:16: error: prototype declaration
  1393. 322 | struct config *Configtable_find(/* struct config * */);
  1394. | ^~~~~~~~~~~~~~~~
  1395. ./tool/lemon.c:4367:9: error: too many arguments to function ‘Configcmp’; expected 0, have 2
  1396. 4367 | if( Configcmp(np->data,key)==0 ) break;
  1397. | ^~~~~~~~~ ~~~~~~~~
  1398. ./tool/lemon.c:4060:5: note: declared here
  1399. 4060 | int Configcmp(a,b)
  1400. | ^~~~~~~~~
  1401. ./tool/lemon.c: In function ‘Configtable_clear’:
  1402. ./tool/lemon.c:4375:6: warning: old-style function definition [-Wold-style-definition]
  1403. 4375 | void Configtable_clear(f)
  1404. | ^~~~~~~~~~~~~~~~~
  1405. ./tool/lemon.c:4377:1: error: number of arguments doesn’t match prototype
  1406. 4377 | {
  1407. | ^
  1408. ./tool/lemon.c:323:6: error: prototype declaration
  1409. 323 | void Configtable_clear(/* int(*)(struct config *) */);
  1410. | ^~~~~~~~~~~~~~~~~
  1411. ./tool/lemon.c:4380:40: error: too many arguments to function ‘f’; expected 0, have 1
  1412. 4380 | if( f ) for(i=0; i<x4a->count; i++) (*f)(x4a->tbl[i].data);
  1413. | ~^~~ ~~~~~~~~~~~~~~~~
  1414. make: *** [Makefile:218: lemon] Error 1
  1415. ==> ERROR: A failure occurred in build().
  1416. Aborting...
Advertisement
Add Comment
Please, Sign In to add comment
Public Pastes
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!