KSGSLeser.cpp 33 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563
  1. #include "KSGSLeser.h"
  2. #include <Datei.h>
  3. #include "../Error/Error.h"
  4. #include "KSGSCompile.h"
  5. #include "../Befehl/KSGSKlasse.h"
  6. #include "../Klassen/KSGSTyp.h"
  7. #include "../Funktionen/KSGSCallback.h"
  8. #include "../Main/KSGScriptObj.h"
  9. using namespace KSGScript;
  10. void KSGScript::removeLehr(Text* txt)
  11. {
  12. if (!txt->getLength())
  13. return;
  14. while (txt->getLength() && (*txt[0] == ' ' || *txt[0] == '\n' || *txt[0] == '\r' || *txt[0] == '\t'))
  15. txt->remove(0);
  16. while (txt->getLength() && (txt->getText()[txt->getLength() - 1] == ' ' || txt->getText()[txt->getLength() - 1] == '\n' ||
  17. txt->getText()[txt->getLength() - 1] == '\r' || txt->getText()[txt->getLength() - 1] == '\t'))
  18. txt->remove(txt->getLength() - 1);
  19. }
  20. void KSGScript::removeKlammer(Text* txt)
  21. {
  22. if (!txt->getLength())
  23. return;
  24. removeLehr(txt);
  25. while (*txt[0] == '(' && txt->getText()[txt->getLength() - 1] == ')')
  26. {
  27. int count = 0;
  28. for (int i = 0; i < txt->getLength(); i++)
  29. {
  30. if (txt->getText()[i] == '(')
  31. count++;
  32. if (txt->getText()[i] == ')')
  33. count--;
  34. if (!count && i != txt->getLength() - 1)
  35. return;
  36. }
  37. txt->remove(0);
  38. txt->remove(txt->getLength() - 1);
  39. removeLehr(txt);
  40. if (!txt->getLength())
  41. return;
  42. }
  43. }
  44. int KSGScript::hatOperator(Text* txt)
  45. {
  46. if (txt->hat("+="))
  47. return KSGS_O_PLUSSET;
  48. if (txt->hat("-="))
  49. return KSGS_O_MINUSSET;
  50. if (txt->hat("*="))
  51. return KSGS_O_MAHLSET;
  52. if (txt->hat("/="))
  53. return KSGS_O_GETEILTSET;
  54. if (txt->hat("&="))
  55. return KSGS_O_UNDSET;
  56. if (txt->hat("|="))
  57. return KSGS_O_ODERSET;
  58. if (txt->hat("=="))
  59. return KSGS_O_GLEICH;
  60. if (txt->hat("<="))
  61. return KSGS_O_KLEINERGLEICH;
  62. if (txt->hat(">="))
  63. return KSGS_O_GREATERGLEICH;
  64. if (txt->hat("!="))
  65. return KSGS_O_UNGLEICH;
  66. if (txt->hat("||"))
  67. return KSGS_O_ODER;
  68. if (txt->hat("&&"))
  69. return KSGS_O_UND;
  70. if (txt->hat("++"))
  71. return KSGS_O_PLUS1;
  72. if (txt->hat("--"))
  73. return KSGS_O_MINUS1;
  74. if (txt->hat("<<"))
  75. return KSGS_O_NACHLINKS;
  76. if (txt->hat(">>"))
  77. return KSGS_O_NACHRECHTS;
  78. if (txt->hat("="))
  79. return KSGS_O_SET;
  80. if (txt->hat("<"))
  81. return KSGS_O_KLEINER;
  82. if (txt->hat(">"))
  83. return KSGS_O_GREATER;
  84. if (txt->hat("|"))
  85. return KSGS_O_BITODER;
  86. if (txt->hat("&"))
  87. return KSGS_O_BITUND;
  88. if (txt->hat("+"))
  89. return KSGS_O_PLUS;
  90. if (txt->hat("-"))
  91. return KSGS_O_MINUS;
  92. if (txt->hat("*"))
  93. return KSGS_O_MAHL;
  94. if (txt->hat("/"))
  95. return KSGS_O_GETEILT;
  96. if (txt->hat("%"))
  97. return KSGS_O_REST;
  98. if (txt->hat("!"))
  99. return KSGS_O_NICHT;
  100. if (txt->hat("~"))
  101. return KSGS_O_BITNICHT;
  102. return -1;
  103. }
  104. int KSGScript::getOperatorPos(Text* txt, int* len)
  105. {
  106. *len = 2;
  107. if (txt->hat("+="))
  108. return txt->positionVon("+=");
  109. if (txt->hat("-="))
  110. return txt->positionVon("-=");
  111. if (txt->hat("*="))
  112. return txt->positionVon("*=");
  113. if (txt->hat("/="))
  114. return txt->positionVon("/=");
  115. if (txt->hat("&="))
  116. return txt->positionVon("&=");
  117. if (txt->hat("|="))
  118. return txt->positionVon("|=");
  119. if (txt->hat("=="))
  120. return txt->positionVon("==");
  121. if (txt->hat("<="))
  122. return txt->positionVon("<=");
  123. if (txt->hat(">="))
  124. return txt->positionVon(">=");
  125. if (txt->hat("!="))
  126. return txt->positionVon("!=");
  127. if (txt->hat("||"))
  128. return txt->positionVon("||");
  129. if (txt->hat("&&"))
  130. return txt->positionVon("&&");
  131. if (txt->hat("++"))
  132. return txt->positionVon("++");
  133. if (txt->hat("--"))
  134. return txt->positionVon("--");
  135. if (txt->hat("<<"))
  136. return txt->positionVon("<<");
  137. if (txt->hat(">>"))
  138. return txt->positionVon(">>");
  139. *len = 1;
  140. if (txt->hat("="))
  141. return txt->positionVon("=");
  142. if (txt->hat("<"))
  143. return txt->positionVon("<");
  144. if (txt->hat(">"))
  145. return txt->positionVon(">");
  146. if (txt->hat("|"))
  147. return txt->positionVon("|");
  148. if (txt->hat("&"))
  149. return txt->positionVon("&");
  150. if (txt->hat("+"))
  151. return txt->positionVon("+");
  152. if (txt->hat("-"))
  153. return txt->positionVon("-");
  154. if (txt->hat("*"))
  155. return txt->positionVon("*");
  156. if (txt->hat("/"))
  157. return txt->positionVon("/");
  158. if (txt->hat("%"))
  159. return txt->positionVon("%");
  160. if (txt->hat("!"))
  161. return txt->positionVon("!");
  162. if (txt->hat("~"))
  163. return txt->positionVon("~");
  164. *len = 0;
  165. return -1;
  166. }
  167. // Lese Strukturen
  168. KSGSLeseBefehl::~KSGSLeseBefehl()
  169. {
  170. int anz = listA.getEintragAnzahl();
  171. for (int i = 0; i < anz; i++)
  172. delete listA.get(i);
  173. anz = listB.getEintragAnzahl();
  174. for (int i = 0; i < anz; i++)
  175. delete listB.get(i);
  176. }
  177. void KSGSLeseFunktion::release()
  178. {
  179. if (!--ref)
  180. delete this;
  181. }
  182. KSGSLeseFunktion::~KSGSLeseFunktion()
  183. {
  184. int anz3 = parameter.getEintragAnzahl();
  185. for (int k = 0; k < anz3; k++)
  186. delete parameter.get(k);
  187. anz3 = befehle.getEintragAnzahl();
  188. for (int k = 0; k < anz3; k++)
  189. delete befehle.get(k);
  190. }
  191. void KSGSLeseKlasse::release()
  192. {
  193. if (!--ref)
  194. delete this;
  195. }
  196. KSGSLeseKlasse::~KSGSLeseKlasse()
  197. {
  198. int anz2 = variablen.getEintragAnzahl();
  199. for (int j = 0; j < anz2; j++)
  200. delete variablen.get(j);
  201. anz2 = funktionen.getEintragAnzahl();
  202. for (int j = 0; j < anz2; j++)
  203. funktionen.get(j)->release();
  204. }
  205. KSGSLeseScript::~KSGSLeseScript()
  206. {
  207. int anz = variablen.getEintragAnzahl();
  208. for (int i = 0; i < anz; i++)
  209. delete variablen.get(i);
  210. anz = funktionen.getEintragAnzahl();
  211. for (int i = 0; i < anz; i++)
  212. funktionen.get(i)->release();
  213. anz = klassen.getEintragAnzahl();
  214. for (int i = 0; i < anz; i++)
  215. klassen.get(i)->release();
  216. }
  217. // Inhalt der KSGSLeser klasse aus KSGSLeser.h
  218. // Konstruktor
  219. KSGSLeser::KSGSLeser(Reader* reader, KSGScriptProcessor* zObj, Text fileName)
  220. : KSGSLeser()
  221. {
  222. this->zObj = zObj;
  223. d = reader;
  224. this->fileName = fileName;
  225. }
  226. // Destruktor
  227. KSGSLeser::~KSGSLeser()
  228. {
  229. delete dat;
  230. }
  231. // protected
  232. KSGSLeser::KSGSLeser()
  233. : ReferenceCounter()
  234. {
  235. errorIgnore = 0;
  236. this->zObj = 0;
  237. d = 0;
  238. dat = 0;
  239. zeile = 0;
  240. mainFuncId = -1;
  241. mausFuncId = -1;
  242. tastaturFuncId = -1;
  243. tickFuncId = -1;
  244. renderFuncId = -1;
  245. }
  246. void KSGSLeser::handleError(int beginn, int ende)
  247. {}
  248. void KSGSLeser::handleKommentar(int beginn, int ende)
  249. {}
  250. void KSGSLeser::handleString(int beginn, int ende)
  251. {}
  252. // Script Laden
  253. bool KSGSLeser::ladeDatei()
  254. {
  255. bool ok = 1;
  256. zeile = 1;
  257. while (!d->istEnde())
  258. {
  259. bool br = 0;
  260. int id = leseNext();
  261. switch (id)
  262. {
  263. case -1: // Ende der Datei
  264. break;
  265. case 1: // Klasse
  266. if (1)
  267. {
  268. KSGSLeseKlasse* k = leseKlasse();
  269. if (!k)
  270. {
  271. error(6, { "Klasse", fileName }, zObj);
  272. br = 1;
  273. }
  274. else
  275. dat->klassen.add(k);
  276. }
  277. break;
  278. case 2: // funktion
  279. if (1)
  280. {
  281. KSGSLeseFunktion* f = leseFunktion();
  282. if (!f)
  283. {
  284. error(6, { "Funktion", fileName }, zObj);
  285. br = 1;
  286. }
  287. else
  288. dat->funktionen.add(f);
  289. }
  290. break;
  291. case 3: // Variable
  292. if (1)
  293. {
  294. KSGSLeseVariable* v = leseVariable();
  295. if (!v)
  296. {
  297. error(6, { "Variable", fileName }, zObj);
  298. br = 1;
  299. }
  300. else
  301. dat->variablen.add(v);
  302. }
  303. break;
  304. case 12: // lesen
  305. if (1)
  306. {
  307. if (!leseBis('('))
  308. {
  309. error(6, { "Lade Anweisung", fileName }, zObj);
  310. br = 1;
  311. break;
  312. }
  313. d->setLPosition(d->getLPosition() + 1, 0);
  314. if (!leseBis('"'))
  315. {
  316. error(6, { "Lade Anweisung", fileName }, zObj);
  317. br = 1;
  318. break;
  319. }
  320. d->setLPosition(d->getLPosition() + 1, 0);
  321. __int64 end = nextPosOf('"', 0);
  322. if (end < 0)
  323. {
  324. error(6, { "Lade Anweisung", fileName }, zObj);
  325. br = 1;
  326. break;
  327. }
  328. char* datei = new char[(int)(end - d->getLPosition()) + 1];
  329. datei[end - d->getLPosition()] = 0;
  330. d->lese(datei, (int)(end - d->getLPosition()));
  331. Text* dPf = zObj->convertPfad(datei);
  332. delete[] datei;
  333. if (!leseBis(')'))
  334. {
  335. error(6, { "Lade Anweisung", fileName }, zObj);
  336. br = 1;
  337. break;
  338. }
  339. d->setLPosition(d->getLPosition() + 1, 0);
  340. Text pf = fileName;
  341. fileName.setText(dPf);
  342. Datei* dat = new Datei();
  343. dat->setDatei(fileName);
  344. if (!dat->open(Datei::Style::lesen))
  345. {
  346. dat->release();
  347. error(4, { fileName }, zObj);
  348. br = 1;
  349. fileName.setText(pf);
  350. break;
  351. }
  352. Reader* tmp = d;
  353. d = dat;
  354. if (!ladeDatei())
  355. {
  356. d = tmp;
  357. error(6, { "Lade Anweisung", fileName }, zObj);
  358. br = 1;
  359. fileName.setText(pf);
  360. break;
  361. }
  362. dat->close();
  363. dat->release();
  364. d = tmp;
  365. fileName.setText(pf);
  366. }
  367. break;
  368. default: // Fehler
  369. error(5, { fileName, Text() += zeile }, zObj);
  370. br = 1;
  371. break;
  372. }
  373. if (id == -1)
  374. break;
  375. if (br)
  376. {
  377. ok = 0;
  378. break;
  379. }
  380. }
  381. d = 0;
  382. return ok;
  383. }
  384. bool KSGSLeser::leseBis(char c)
  385. {
  386. __int64 pos = d->getLPosition();
  387. int tmpZ = zeile;
  388. char byte = 0;
  389. bool kommentar = 0;
  390. int kBeg = 0;
  391. bool slash = 0;
  392. bool gefunden = 0;
  393. bool inString = 0;
  394. bool inChar = 0;
  395. int sBeg = 0;
  396. while (!d->istEnde())
  397. {
  398. d->lese(&byte, 1);
  399. if (byte == '\n')
  400. {
  401. zeile++;
  402. if (kommentar)
  403. handleKommentar(kBeg, (int)d->getLPosition());
  404. kommentar = 0;
  405. continue;
  406. }
  407. if (byte == '"' && !inChar && !kommentar)
  408. {
  409. if (inString)
  410. handleString(sBeg, (int)d->getLPosition());
  411. inString = !inString;
  412. sBeg = (int)d->getLPosition() - 1;
  413. }
  414. if (byte == '\'' && !inString && !kommentar)
  415. {
  416. if (inChar)
  417. handleString(sBeg, (int)d->getLPosition());
  418. inChar = !inChar;
  419. sBeg = (int)d->getLPosition() - 1;
  420. }
  421. if (byte == '#')
  422. {
  423. kBeg = (int)d->getLPosition() - 1;
  424. kommentar = 1;
  425. continue;
  426. }
  427. if (byte == '/')
  428. {
  429. if (slash)
  430. {
  431. kBeg = (int)d->getLPosition() - 2;
  432. kommentar = 1;
  433. slash = 0;
  434. }
  435. else
  436. slash = 1;
  437. continue;
  438. }
  439. else
  440. slash = 0;
  441. if (byte == c && !kommentar)
  442. {
  443. gefunden = 1;
  444. break;
  445. }
  446. }
  447. if (d->istEnde() && !gefunden)
  448. {
  449. handleError((int)d->getLPosition() - 1, (int)d->getLPosition());
  450. d->setLPosition(pos, 0);
  451. zeile = tmpZ;
  452. return 0;
  453. }
  454. d->setLPosition(d->getLPosition() - 1, 0);
  455. return 1;
  456. }
  457. __int64 KSGSLeser::nextPosOf(char c, char c2)
  458. {
  459. __int64 pos = d->getLPosition();
  460. char byte = 0;
  461. bool kommentar = 0;
  462. int kBeg = 0;
  463. bool slash = 0;
  464. int count = 0;
  465. bool gefunden = 0;
  466. bool inString = 0;
  467. bool inChar = 0;
  468. int sBeg = 0;
  469. while (!d->istEnde())
  470. {
  471. d->lese(&byte, 1);
  472. if (byte == '\n')
  473. {
  474. if (kommentar)
  475. handleKommentar(kBeg, (int)d->getLPosition());
  476. kommentar = 0;
  477. continue;
  478. }
  479. if (byte == '"' && !inChar && !kommentar)
  480. {
  481. if (inString)
  482. handleString(sBeg, (int)d->getLPosition());
  483. inString = !inString;
  484. sBeg = (int)d->getLPosition() - 1;
  485. }
  486. if (byte == '\'' && !inString && !kommentar)
  487. {
  488. if (inChar)
  489. handleString(sBeg, (int)d->getLPosition());
  490. inChar = !inChar;
  491. sBeg = (int)d->getLPosition() - 1;
  492. }
  493. if (byte == '#')
  494. {
  495. kBeg = (int)d->getLPosition() - 1;
  496. kommentar = 1;
  497. continue;
  498. }
  499. if (byte == '/')
  500. {
  501. if (slash)
  502. {
  503. kBeg = (int)d->getLPosition() - 2;
  504. kommentar = 1;
  505. slash = 0;
  506. }
  507. else
  508. slash = 1;
  509. continue;
  510. }
  511. else
  512. slash = 0;
  513. if (!kommentar)
  514. {
  515. if (byte == c2)
  516. {
  517. count++;
  518. continue;
  519. }
  520. if (byte == c)
  521. {
  522. if (!count)
  523. {
  524. gefunden = 1;
  525. break;
  526. }
  527. count--;
  528. continue;
  529. }
  530. }
  531. }
  532. if (d->istEnde() && !gefunden)
  533. {
  534. handleError((int)d->getLPosition() - 1, (int)d->getLPosition());
  535. d->setLPosition(pos, 0);
  536. return -1;
  537. }
  538. __int64 ret = d->getLPosition() - 1;
  539. d->setLPosition(pos, 0);
  540. return ret;
  541. }
  542. bool KSGSLeser::leseBisText()
  543. {
  544. __int64 pos = d->getLPosition();
  545. char c = 0;
  546. bool kommentar = 0;
  547. int kBeg = 0;
  548. bool slash = 0;
  549. bool gefunden = 0;
  550. bool inString = 0;
  551. bool inChar = 0;
  552. int sBeg = 0;
  553. while (!d->istEnde())
  554. {
  555. d->lese(&c, 1);
  556. if (c == '\n')
  557. {
  558. zeile++;
  559. if (kommentar)
  560. handleKommentar(kBeg, (int)d->getLPosition());
  561. kommentar = 0;
  562. continue;
  563. }
  564. if (c == '"' && !inChar && !kommentar)
  565. {
  566. if (inString)
  567. handleString(sBeg, (int)d->getLPosition());
  568. inString = !inString;
  569. sBeg = (int)d->getLPosition() - 1;
  570. }
  571. if (c == '\'' && !inString && !kommentar)
  572. {
  573. if (inChar)
  574. handleString(sBeg, (int)d->getLPosition());
  575. inChar = !inChar;
  576. sBeg = (int)d->getLPosition() - 1;
  577. }
  578. if (c == '#')
  579. {
  580. kBeg = (int)d->getLPosition() - 1;
  581. kommentar = 1;
  582. continue;
  583. }
  584. if (c == '/')
  585. {
  586. if (slash)
  587. {
  588. kBeg = (int)d->getLPosition() - 2;
  589. kommentar = 1;
  590. slash = 0;
  591. }
  592. else
  593. slash = 1;
  594. continue;
  595. }
  596. else
  597. slash = 0;
  598. if (!istLehr(c) && !kommentar)
  599. {
  600. gefunden = 1;
  601. break;
  602. }
  603. }
  604. if (d->istEnde() && !gefunden)
  605. {
  606. d->setLPosition(pos, 0);
  607. return 0;
  608. }
  609. d->setLPosition(d->getLPosition() - 1, 0);
  610. return 1;
  611. }
  612. int KSGSLeser::leseNext()
  613. {
  614. if (!leseBisText())
  615. return -1;
  616. __int64 pos = d->getLPosition();
  617. int ret = 0;
  618. Text txt = "";
  619. char byte[] = { 0, 0 };
  620. d->lese(byte, 1);
  621. while (!istTrenner(byte[0]) && !d->istEnde())
  622. {
  623. txt.append(byte);
  624. d->lese(byte, 1);
  625. }
  626. if (d->istEnde() || !txt.getLength())
  627. {
  628. d->setLPosition(pos, 0);
  629. return -1;
  630. }
  631. if (txt.istGleich("class"))
  632. ret = 1;
  633. if (txt.istGleich("func"))
  634. ret = 2;
  635. if (txt.istGleich("var"))
  636. ret = 3;
  637. if (txt.istGleich("public"))
  638. ret = 4;
  639. if (txt.istGleich("private"))
  640. ret = 5;
  641. if (txt.istGleich("if"))
  642. ret = 6;
  643. if (txt.istGleich("for"))
  644. ret = 7;
  645. if (txt.istGleich("while"))
  646. ret = 8;
  647. if (txt.istGleich("return"))
  648. ret = 9;
  649. if (txt.istGleich("break"))
  650. ret = 10;
  651. if (txt.istGleich("continue"))
  652. ret = 11;
  653. if (txt.istGleich("lesen"))
  654. ret = 12;
  655. d->setLPosition(pos, 0);
  656. return ret;
  657. }
  658. bool KSGSLeser::istTrenner(char c)
  659. {
  660. return !((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9')
  661. || c == '_' || c == 'ä' || c == 'ö' || c == 'ü' || c == 'Ä' || c == 'Ö' || c == 'Ü' || c == 'ß');
  662. }
  663. bool KSGSLeser::istLehr(char c)
  664. {
  665. return c == ' ' || c == '\n' || c == '\r' || c == '\t';
  666. }
  667. KSGSLeseKlasse* KSGSLeser::leseKlasse()
  668. {
  669. KSGSLeseKlasse* ret = new KSGSLeseKlasse();
  670. ret->debug.datei.setText(fileName);
  671. ret->debug.zeile = zeile;
  672. d->setLPosition(d->getLPosition() + 5, 0); // 'class' überspringen
  673. if (!leseBisText()) // Bis zum beginn des Klassennamens lesen
  674. {
  675. handleError((int)d->getLPosition() - 1, (int)d->getLPosition());
  676. ret->release();
  677. return 0;
  678. }
  679. char byte[] = { 0, 0 }; // Klassenname lesen
  680. d->lese(byte, 1);
  681. while (!istTrenner(*byte))
  682. {
  683. ret->name.append(byte);
  684. d->lese(byte, 1);
  685. }
  686. if (!leseBis('{')) // Bis zum beginn der Klasse lesen
  687. {
  688. ret->release();
  689. return 0;
  690. }
  691. d->setLPosition(d->getLPosition() + 1, 0);
  692. bool sichtbar = 0;
  693. __int64 ende = nextPosOf('}', '{'); // Ende der Klasse
  694. if (ende < 0)
  695. {
  696. ret->release();
  697. return 0;
  698. }
  699. while (d->getLPosition() < ende) // Inhalt der Klasse lesen
  700. {
  701. int id = leseNext();
  702. if (id == -1)
  703. break;
  704. switch (id)
  705. {
  706. case 2: // Funktion
  707. if (1)
  708. {
  709. KSGSLeseFunktion* f = leseFunktion();
  710. if (!f)
  711. {
  712. ret->release();
  713. return 0;
  714. }
  715. ret->funktionen.add(f);
  716. ret->fSichtbar.add(sichtbar);
  717. }
  718. break;
  719. case 3: // Variable
  720. if (1)
  721. {
  722. KSGSLeseVariable* v = leseVariable();
  723. if (!v)
  724. {
  725. ret->release();
  726. return 0;
  727. }
  728. ret->variablen.add(v);
  729. ret->vSichtbar.add(sichtbar);
  730. }
  731. break;
  732. case 4: // public
  733. sichtbar = 1;
  734. d->setLPosition(d->getLPosition() + 6, 0);
  735. if (!leseBis(':'))
  736. {
  737. ret->release();
  738. return 0;
  739. }
  740. d->setLPosition(d->getLPosition() + 1, 0);
  741. break;
  742. case 5: // private
  743. sichtbar = 0;
  744. d->setLPosition(d->getLPosition() + 7, 0);
  745. if (!leseBis(':'))
  746. {
  747. ret->release();
  748. return 0;
  749. }
  750. d->setLPosition(d->getLPosition() + 1, 0);
  751. break;
  752. default:
  753. ret->release();
  754. return 0;
  755. }
  756. }
  757. if (d->getLPosition() > ende)
  758. {
  759. handleError((int)d->getLPosition() - 1, (int)d->getLPosition());
  760. ret->release();
  761. return 0;
  762. }
  763. d->setLPosition(ende + 1, 0);
  764. if (!leseBis(';')) // ';' Nach einer Klasse überlesen
  765. {
  766. ret->release();
  767. return 0;
  768. }
  769. d->setLPosition(d->getLPosition() + 1, 0);
  770. return ret;
  771. }
  772. KSGSLeseFunktion* KSGSLeser::leseFunktion()
  773. {
  774. KSGSLeseFunktion* ret = new KSGSLeseFunktion();
  775. ret->debug.datei.setText(fileName);
  776. ret->debug.zeile = zeile;
  777. d->setLPosition(d->getLPosition() + 4, 0); // 'func' überspringen
  778. if (!leseBisText())
  779. {
  780. ret->release();
  781. return 0;
  782. }
  783. char byte[] = { 0, 0 }; // Rückgabetyp der Funktion lesen
  784. d->lese(byte, 1);
  785. while (!istTrenner(*byte))
  786. {
  787. ret->typ.append(byte);
  788. d->lese(byte, 1);
  789. }
  790. d->setLPosition(d->getLPosition() - 1, 0);
  791. if (!leseBisText())
  792. {
  793. handleError((int)d->getLPosition() - 1, (int)d->getLPosition());
  794. ret->release();
  795. return 0;
  796. }
  797. d->lese(byte, 1); // Name der Funktion lesen
  798. while (!istTrenner(*byte))
  799. {
  800. ret->name.append(byte);
  801. d->lese(byte, 1);
  802. }
  803. d->setLPosition(d->getLPosition() - 1, 0);
  804. if (!leseBis('(')) // Parameterbeginn
  805. {
  806. ret->release();
  807. return 0;
  808. }
  809. d->setLPosition(d->getLPosition() + 1, 0);
  810. __int64 paramEnde = nextPosOf(')', '(');
  811. if (paramEnde < 0)
  812. {
  813. ret->release();
  814. return 0;
  815. }
  816. while (d->getLPosition() < paramEnde)
  817. {
  818. KSGSLeseVariable* param = leseVariable(1); // Übergabeparameter einlesen
  819. if (!param)
  820. break;
  821. ret->parameter.add(param);
  822. }
  823. d->setLPosition(paramEnde + 1, 0);
  824. if (!leseBis('{')) // Funktionsrumpf beginn
  825. {
  826. ret->release();
  827. return 0;
  828. }
  829. d->setLPosition(d->getLPosition() + 1, 0);
  830. __int64 funkEnde = nextPosOf('}', '{'); // Ende der Funktion
  831. if (funkEnde < 0)
  832. {
  833. ret->release();
  834. return 0;
  835. }
  836. while (d->getLPosition() < funkEnde)
  837. {
  838. KSGSLeseBefehl* bef = leseBefehl(); // Befehle einlesen
  839. if (!bef)
  840. break;
  841. else
  842. ret->befehle.add(bef);
  843. if (!leseBisText())
  844. {
  845. ret->release();
  846. return 0;
  847. }
  848. }
  849. d->setLPosition(funkEnde + 1, 0); // '}' am ende der Funktion überlesen
  850. return ret;
  851. }
  852. KSGSLeseVariable* KSGSLeser::leseVariable(bool param)
  853. {
  854. KSGSLeseVariable* ret = new KSGSLeseVariable();
  855. ret->debug.datei.setText(fileName);
  856. ret->debug.zeile = zeile;
  857. if (!param)
  858. d->setLPosition(d->getLPosition() + 3, 0); // 'var' überspringen
  859. __int64 endPos = 0;
  860. if (param)
  861. {
  862. endPos = nextPosOf(')', 0);
  863. if (endPos < 0)
  864. {
  865. handleError((int)d->getLPosition() - 1, (int)d->getLPosition());
  866. delete ret;
  867. return 0;
  868. }
  869. }
  870. if (!leseBisText())
  871. {
  872. delete ret;
  873. return 0;
  874. }
  875. if (param && d->getLPosition() >= endPos)
  876. {
  877. delete ret;
  878. return 0;
  879. }
  880. char byte[] = { 0, 0 }; // Variablentyp lesen
  881. d->lese(byte, 1);
  882. while (!istTrenner(*byte))
  883. {
  884. ret->typ.append(byte);
  885. d->lese(byte, 1);
  886. }
  887. d->setLPosition(d->getLPosition() - 1, 0);
  888. if (!leseBisText())
  889. {
  890. handleError((int)d->getLPosition() - 1, (int)d->getLPosition());
  891. delete ret;
  892. return 0;
  893. }
  894. d->lese(byte, 1); // Variablenname lesen
  895. while (!istTrenner(*byte))
  896. {
  897. ret->name.append(byte);
  898. d->lese(byte, 1);
  899. }
  900. d->setLPosition(d->getLPosition() - 1, 0);
  901. __int64 ende = nextPosOf(';', 0);
  902. if (ende < 0)
  903. {
  904. delete ret;
  905. return 0;
  906. }
  907. if (param)
  908. {
  909. errorIgnore = 1;
  910. __int64 tmp = nextPosOf(',', 0);
  911. errorIgnore = 0;
  912. if (tmp >= 0 && tmp < endPos)
  913. ende = tmp;
  914. else
  915. ende = endPos;
  916. }
  917. errorIgnore = 1;
  918. __int64 gleich = nextPosOf('=', 0);
  919. errorIgnore = 0;
  920. if (gleich < ende && gleich >= 0) // prüfen ob die variable gesetzt wird
  921. {
  922. if (!leseBis('='))
  923. {
  924. delete ret;
  925. return 0;
  926. }
  927. d->setLPosition(d->getLPosition() + 1, 0);
  928. }
  929. if (leseBisText())
  930. {
  931. if (d->getLPosition() < ende)
  932. {
  933. while (d->getLPosition() < ende) // Wert der Variable lesen
  934. {
  935. d->lese(byte, 1);
  936. ret->wert.append(byte);
  937. }
  938. }
  939. }
  940. while (istLehr(ret->wert.getText()[ret->wert.getLength() - 1]) && ret->wert.getLength() > 0)
  941. {
  942. if (ret->wert.getText()[ret->wert.getLength() - 1] == '\n')
  943. zeile++;
  944. if (!(ret->wert.getLength() - 1))
  945. {
  946. ret->wert.setText("");
  947. break;
  948. }
  949. ret->wert.setText(ret->wert.getText(), ret->wert.getLength() - 1);
  950. }
  951. if (d->getLPosition() > ende)
  952. {
  953. handleError((int)d->getLPosition() - 1, (int)d->getLPosition());
  954. delete ret;
  955. return 0;
  956. }
  957. d->setLPosition(ende + 1, 0); // ';' oder bei param ')' oder ',' am Ende überlesen
  958. return ret;
  959. }
  960. KSGSLeseBefehl* KSGSLeser::leseBefehl()
  961. {
  962. __int64 fEnde = nextPosOf('}', '{');
  963. if (fEnde < 0)
  964. return 0;
  965. int typ = leseNext();
  966. if (typ < 0)
  967. return 0;
  968. KSGSLeseBefehl* ret = new KSGSLeseBefehl();
  969. ret->debug.datei.setText(fileName);
  970. ret->debug.zeile = zeile;
  971. ret->typ = typ;
  972. switch (typ)
  973. {
  974. case 0:
  975. case 3: // var
  976. if (1)
  977. {
  978. __int64 endPos = nextPosOf(';', 0);
  979. if (endPos < 0)
  980. {
  981. delete ret;
  982. return 0;
  983. }
  984. int len = (int)(endPos - d->getLPosition());
  985. if (len)
  986. {
  987. char* txt = new char[len + 1];
  988. txt[len] = 0;
  989. d->lese(txt, len);
  990. ret->befehl = txt;
  991. delete[] txt;
  992. }
  993. d->setLPosition(endPos + 1, 0);
  994. }
  995. break;
  996. case 6: // if
  997. if (1)
  998. {
  999. if (!leseBis('('))
  1000. {
  1001. delete ret;
  1002. return 0;
  1003. }
  1004. d->setLPosition(d->getLPosition() + 1, 0);
  1005. __int64 endPos = nextPosOf(')', '(');
  1006. if (endPos < 0)
  1007. {
  1008. delete ret;
  1009. return 0;
  1010. }
  1011. int len = (int)(endPos - d->getLPosition());
  1012. if (len)
  1013. {
  1014. char* txt = new char[len + 1];
  1015. txt[len] = 0;
  1016. d->lese(txt, len);
  1017. ret->befehl = txt;
  1018. delete[] txt;
  1019. }
  1020. d->setLPosition(endPos + 1, 0);
  1021. if (!leseBis('{'))
  1022. {
  1023. delete ret;
  1024. return 0;
  1025. }
  1026. d->setLPosition(d->getLPosition() + 1, 0);
  1027. endPos = nextPosOf('}', '{');
  1028. if (endPos < 0)
  1029. {
  1030. delete ret;
  1031. return 0;
  1032. }
  1033. while (d->getLPosition() < endPos)
  1034. {
  1035. KSGSLeseBefehl* tmp = leseBefehl();
  1036. if (!tmp)
  1037. break;
  1038. else
  1039. ret->listA.add(tmp);
  1040. }
  1041. d->setLPosition(endPos + 1, 0);
  1042. int tmpZ = zeile;
  1043. if (!leseBisText())
  1044. {
  1045. handleError((int)d->getLPosition() - 1, (int)d->getLPosition());
  1046. delete ret;
  1047. return 0;
  1048. }
  1049. char* el = new char[5];
  1050. if (d->getLPosition() + 4 <= fEnde)
  1051. d->lese(el, 4);
  1052. else
  1053. el[0] = 0;
  1054. el[4] = 0;
  1055. if (Text("else").istGleich(el))
  1056. {
  1057. if (!leseBis('{'))
  1058. {
  1059. delete ret;
  1060. return 0;
  1061. }
  1062. d->setLPosition(d->getLPosition() + 1, 0);
  1063. endPos = nextPosOf('}', '{');
  1064. if (endPos < 0)
  1065. {
  1066. delete ret;
  1067. return 0;
  1068. }
  1069. while (d->getLPosition() < endPos)
  1070. {
  1071. KSGSLeseBefehl* tmp = leseBefehl();
  1072. if (!tmp)
  1073. break;
  1074. else
  1075. ret->listB.add(tmp);
  1076. }
  1077. d->setLPosition(endPos + 1, 0);
  1078. }
  1079. else
  1080. {
  1081. d->setLPosition(endPos + 1, 0);
  1082. zeile = tmpZ;
  1083. }
  1084. delete[] el;
  1085. }
  1086. break;
  1087. case 7: // for
  1088. case 8: // while
  1089. if (1)
  1090. {
  1091. if (!leseBis('('))
  1092. {
  1093. delete ret;
  1094. return 0;
  1095. }
  1096. d->setLPosition(d->getLPosition() + 1, 0);
  1097. __int64 endPos = nextPosOf(')', '(');
  1098. if (endPos < 0)
  1099. {
  1100. delete ret;
  1101. return 0;
  1102. }
  1103. int len = (int)(endPos - d->getLPosition());
  1104. if (len)
  1105. {
  1106. char* txt = new char[len + 1];
  1107. txt[len] = 0;
  1108. d->lese(txt, len);
  1109. ret->befehl = txt;
  1110. delete[] txt;
  1111. }
  1112. d->setLPosition(endPos + 1, 0);
  1113. if (!leseBis('{'))
  1114. {
  1115. delete ret;
  1116. return 0;
  1117. }
  1118. d->setLPosition(d->getLPosition() + 1, 0);
  1119. endPos = nextPosOf('}', '{');
  1120. if (endPos < 0)
  1121. {
  1122. delete ret;
  1123. return 0;
  1124. }
  1125. while (d->getLPosition() < endPos)
  1126. {
  1127. KSGSLeseBefehl* tmp = leseBefehl();
  1128. if (!tmp)
  1129. break;
  1130. else
  1131. ret->listA.add(tmp);
  1132. }
  1133. d->setLPosition(endPos + 1, 0);
  1134. }
  1135. break;
  1136. case 9: // return
  1137. if (1)
  1138. {
  1139. __int64 endPos = nextPosOf(';', 0);
  1140. if (endPos < 0)
  1141. {
  1142. delete ret;
  1143. return 0;
  1144. }
  1145. int len = (int)(endPos - d->getLPosition());
  1146. if (len)
  1147. {
  1148. char* txt = new char[len + 1];
  1149. txt[len] = 0;
  1150. d->lese(txt, len);
  1151. ret->befehl = txt;
  1152. delete[] txt;
  1153. }
  1154. d->setLPosition(endPos + 1, 0);
  1155. }
  1156. break;
  1157. case 10: // break
  1158. case 11: // continue
  1159. if (1)
  1160. {
  1161. __int64 endPos = nextPosOf(';', 0);
  1162. if (endPos < 0)
  1163. {
  1164. delete ret;
  1165. return 0;
  1166. }
  1167. d->setLPosition(endPos + 1, 0);
  1168. }
  1169. break;
  1170. default:
  1171. handleError((int)d->getLPosition() - 1, (int)d->getLPosition());
  1172. delete ret;
  1173. return 0;
  1174. }
  1175. if (d->getLPosition() > fEnde)
  1176. {
  1177. handleError((int)d->getLPosition() - 1, (int)d->getLPosition());
  1178. delete ret;
  1179. return 0;
  1180. }
  1181. ret->befehl.ersetzen("->", ".");
  1182. return ret;
  1183. }
  1184. // Script Compilieren
  1185. bool KSGSLeser::compileKlasse(KSGSLeseKlasse* zLK, KSGSCompKlassTable* zKT)
  1186. {
  1187. if (!zKT->hat(zLK->name))
  1188. {
  1189. error(10, {}, zObj);
  1190. return 0;
  1191. }
  1192. KSGSCompileKlasse* k = zKT->get(zLK->name);
  1193. int lFAnz = zLK->funktionen.getEintragAnzahl();
  1194. for (int i = 0; i < lFAnz; i++)
  1195. {
  1196. if (!compileFunktion(zLK->funktionen.get(i), zKT, &k->funcs, 1 + !zLK->fSichtbar.get(i)))
  1197. return 0;
  1198. }
  1199. k->vars.addVariable("this", new KSGSCompileVariable(k->id, 2));
  1200. int lVAnz = zLK->variablen.getEintragAnzahl();
  1201. for (int i = 0; i < lVAnz; i++)
  1202. {
  1203. auto tmp = zKT->get(zLK->variablen.get(i)->typ);
  1204. if (!tmp)
  1205. {
  1206. error(11, { zLK->debug.datei, Text() += zLK->debug.zeile, zLK->variablen.get(i)->typ, zLK->variablen.get(i)->name }, zObj);
  1207. return 0;
  1208. }
  1209. if (!k->vars.addVariable(zLK->variablen.get(i)->name, new KSGSCompileVariable(tmp->id, 1 + !zLK->vSichtbar.get(i))))
  1210. {
  1211. error(9, { zLK->variablen.get(i)->debug.datei, Text() += zLK->variablen.get(i)->debug.zeile, zLK->variablen.get(i)->name }, zObj);
  1212. return 0;
  1213. }
  1214. }
  1215. return 1;
  1216. }
  1217. bool KSGSLeser::compileFunktion(KSGSLeseFunktion* zLF, KSGSCompKlassTable* zKT, KSGSCompFuncTable* zFT, int s)
  1218. {
  1219. KSGSCompileFunktion* f = new KSGSCompileFunktion(zKT->get(zLF->typ)->id, s, {});
  1220. int anz = zLF->parameter.getEintragAnzahl();
  1221. for (int j = 0; j < anz; j++)
  1222. {
  1223. auto tmp = zKT->get(zLF->parameter.get(j)->typ);
  1224. if (tmp)
  1225. f->parameterTyp.add(tmp->id);
  1226. else
  1227. {
  1228. error(11, { zLF->debug.datei, Text() += zLF->debug.zeile, zLF->parameter.get(j)->typ, zLF->parameter.get(j)->name }, zObj);
  1229. return 0;
  1230. }
  1231. }
  1232. if (!zFT->addFunktion(zLF->name, f))
  1233. {
  1234. error(8, { zLF->debug.datei, Text() += zLF->debug.zeile, zLF->name }, zObj);
  1235. return 0;
  1236. }
  1237. return 1;
  1238. }
  1239. KSGSVariableDef* KSGSLeser::compileVariable(KSGSLeseVariable* zLV, KSGSCompKlassTable* zKT, int id)
  1240. {
  1241. if (!zKT->hat(zLV->typ))
  1242. {
  1243. error(11, { zLV->debug.datei, Text() += zLV->debug.zeile, zLV->typ, zLV->name }, zObj);
  1244. return 0;
  1245. }
  1246. KSGSVariableDef* ret = new KSGSVariableDef();
  1247. ret->id = id;
  1248. ret->sichtbar = 0;
  1249. ret->typId = zKT->get(zLV->typ)->id;
  1250. ret->wert.setText(zLV->wert);
  1251. return ret;
  1252. }
  1253. KSGSKlasse* KSGSLeser::buildKlasse(KSGSLeseKlasse* zLK, KSGSCompKlassTable* zKT, KSGSCompFuncTable* zFT, KSGSCompVarTable* zVT)
  1254. {
  1255. if (!zKT->hat(zLK->name))
  1256. {
  1257. error(10, {}, zObj);
  1258. return 0;
  1259. }
  1260. KSGSKlasse* ret = new KSGSKlasse(zKT->get(zLK->name)->id);
  1261. int anz = zLK->funktionen.getEintragAnzahl();
  1262. for (int i = 0; i < anz; i++)
  1263. {
  1264. KSGSFunktion* f = buildFunktion(zLK->funktionen.get(i), zKT, zFT, zVT, zLK->name);
  1265. if (!f)
  1266. {
  1267. ret->release();
  1268. return 0;
  1269. }
  1270. ret->addFunktion(f);
  1271. }
  1272. anz = zLK->variablen.getEintragAnzahl();
  1273. for (int i = 0; i < anz; i++)
  1274. {
  1275. KSGSVariableDef* v = compileVariable(zLK->variablen.get(i), zKT, i);
  1276. if (!v)
  1277. {
  1278. ret->release();
  1279. return 0;
  1280. }
  1281. v->sichtbar = 1 + !zLK->vSichtbar.get(i);
  1282. ret->addVariable(v);
  1283. }
  1284. return ret;
  1285. }
  1286. KSGSFunktion* KSGSLeser::buildFunktion(KSGSLeseFunktion* zLF, KSGSCompKlassTable* zKT, KSGSCompFuncTable* zFT, KSGSCompVarTable* zVT, const char* klassName)
  1287. {
  1288. KSGSCompFuncTable* ft = zFT;
  1289. if (klassName)
  1290. ft = &zKT->get(klassName)->funcs;
  1291. if (!ft->hat(zLF->name))
  1292. {
  1293. error(10, {}, zObj);
  1294. return 0;
  1295. }
  1296. KSGSFunktion* ret = new KSGSFunktion(ft->get(zLF->name)->id, ft->get(zLF->name)->sichtbar, zKT->get(zLF->typ)->id);
  1297. ret->setName(zLF->name);
  1298. int anz = zLF->parameter.getEintragAnzahl();
  1299. for (int i = 0; i < anz; i++)
  1300. {
  1301. KSGSVariableDef* v = compileVariable(zLF->parameter.get(i), zKT, i);
  1302. if (!v)
  1303. {
  1304. ret->release();
  1305. return 0;
  1306. }
  1307. v->sichtbar = 3;
  1308. ret->addParameter(v);
  1309. auto tmp = zKT->get(zLF->parameter.get(i)->typ);
  1310. if (!tmp)
  1311. {
  1312. error(11, { zLF->debug.datei, Text() += zLF->debug.zeile, zLF->parameter.get(i)->typ, zLF->parameter.get(i)->name }, zObj);
  1313. return 0;
  1314. }
  1315. ft->get(zLF->name)->vars.addVariable(zLF->parameter.get(i)->name, new KSGSCompileVariable(tmp->id, 3));
  1316. }
  1317. anz = zLF->befehle.getEintragAnzahl();
  1318. for (int i = 0; i < anz; i++)
  1319. {
  1320. KSGSBefehl* b = buildBefehl(zLF->befehle.get(i), zKT, zFT, zVT, klassName, zLF->name);
  1321. if (!b)
  1322. {
  1323. ret->release();
  1324. return 0;
  1325. }
  1326. ret->addBefehl(b);
  1327. }
  1328. return ret;
  1329. }
  1330. KSGSBefehl* KSGSLeser::buildBefehl(KSGSLeseBefehl* zLB, KSGSCompKlassTable* zKT, KSGSCompFuncTable* zFT, KSGSCompVarTable* zVT, const char* klassName, const char* funktionName)
  1331. {
  1332. KSGSBefehl* ret = 0;
  1333. zLB->befehl.setSuchGrenzen('(', ')');
  1334. removeKlammer(&zLB->befehl);
  1335. switch (zLB->typ)
  1336. {
  1337. case 0: // call oder operator
  1338. if (1)
  1339. {
  1340. if (hatOperator(&zLB->befehl) >= 0)
  1341. ret = new KSGSOperatorBefehl(zObj, zLB, zKT, zFT, zVT, klassName, funktionName);
  1342. else
  1343. ret = new KSGSCallBefehl(zObj, zLB, zKT, zFT, zVT, klassName, funktionName);
  1344. }
  1345. break;
  1346. case 3: // var
  1347. ret = new KSGSVariableBefehl(zObj, zLB, zKT, zFT, zVT, klassName, funktionName);
  1348. break;
  1349. case 6: // if
  1350. ret = new KSGSIfBefehl(zObj, zLB, zKT, zFT, zVT, klassName, funktionName);
  1351. break;
  1352. case 7: // for
  1353. ret = new KSGSForBefehl(zObj, zLB, zKT, zFT, zVT, klassName, funktionName);
  1354. break;
  1355. case 8: // while
  1356. ret = new KSGSWhileBefehl(zObj, zLB, zKT, zFT, zVT, klassName, funktionName);
  1357. break;
  1358. case 9: // return
  1359. ret = new KSGSReturnBefehl(zObj, zLB, zKT, zFT, zVT, klassName, funktionName);
  1360. break;
  1361. case 10: // break
  1362. ret = new KSGSBreakBefehl(zLB, zKT, zFT, zVT, klassName, funktionName);
  1363. break;
  1364. case 11: // continue
  1365. ret = new KSGSContinueBefehl(zLB, zKT, zFT, zVT, klassName, funktionName);
  1366. break;
  1367. }
  1368. if (!ret)
  1369. error(13, { zLB->debug.datei, Text() += zLB->debug.zeile, zLB->befehl }, zObj);
  1370. if (ret && ret->hatFehler())
  1371. ret = (KSGSBefehl*)ret->release();
  1372. return ret;
  1373. }
  1374. // nicht constant
  1375. bool KSGSLeser::laden()
  1376. {
  1377. delete dat;
  1378. dat = new KSGSLeseScript();
  1379. bool ok = ladeDatei();
  1380. return ok;
  1381. }
  1382. bool KSGSLeser::compile(RCArray< KSGSKlasse >* klassen, RCArray< KSGSFunktion >* funktionen, Array< KSGSVariableDef* >* variablen)
  1383. {
  1384. // Klassen Tabelle
  1385. KSGSCompKlassTable* klassT = new KSGSCompKlassTable();
  1386. int kAnz = dat->klassen.getEintragAnzahl();
  1387. for (int i = 0; i < kAnz; i++)
  1388. {
  1389. if (!klassT->addKlasse(dat->klassen.get(i)->name, new KSGSCompileKlasse()))
  1390. {
  1391. error(7, { dat->klassen.get(i)->debug.datei, Text() += dat->klassen.get(i)->debug.zeile, dat->klassen.get(i)->name }, zObj);
  1392. klassT->release();
  1393. return 0;
  1394. }
  1395. }
  1396. // Funktions Tabelle
  1397. KSGSCompFuncTable* funcT = new KSGSCompFuncTable();
  1398. funcT->addFunktion("Rückruf", new KSGSCompileFunktion(KSGS_VOID, 0, {}));
  1399. int fAnz = dat->funktionen.getEintragAnzahl();
  1400. for (int i = 0; i < fAnz; i++)
  1401. {
  1402. if (!compileFunktion(dat->funktionen.get(i), klassT, funcT))
  1403. {
  1404. error(8, { dat->funktionen.get(i)->debug.datei, Text() += dat->funktionen.get(i)->debug.zeile, dat->funktionen.get(i)->name }, zObj);
  1405. klassT->release();
  1406. funcT->release();
  1407. return 0;
  1408. }
  1409. if (dat->funktionen.get(i)->name.istGleich("start"))
  1410. mainFuncId = funcT->get("start")->id;
  1411. if (dat->funktionen.get(i)->name.istGleich("maus"))
  1412. mausFuncId = funcT->get("maus")->id;
  1413. if (dat->funktionen.get(i)->name.istGleich("tastatur"))
  1414. tastaturFuncId = funcT->get("tastatur")->id;
  1415. if (dat->funktionen.get(i)->name.istGleich("tick"))
  1416. tickFuncId = funcT->get("tick")->id;
  1417. if (dat->funktionen.get(i)->name.istGleich("render"))
  1418. renderFuncId = funcT->get("render")->id;
  1419. }
  1420. // Variablen Tabelle
  1421. KSGSCompVarTable* varT = new KSGSCompVarTable();
  1422. int vAnz = dat->variablen.getEintragAnzahl();
  1423. for (int i = 0; i < vAnz; i++)
  1424. {
  1425. auto tmp = klassT->get(dat->variablen.get(i)->typ);
  1426. if (!tmp)
  1427. {
  1428. error(11, { dat->variablen.get(i)->debug.datei, Text() += dat->variablen.get(i)->debug.zeile, dat->variablen.get(i)->typ, dat->variablen.get(i)->name }, zObj);
  1429. return 0;
  1430. }
  1431. if (!varT->addVariable(dat->variablen.get(i)->name, new KSGSCompileVariable(klassT->get(dat->variablen.get(i)->typ)->id, 0)))
  1432. {
  1433. error(9, { dat->variablen.get(i)->debug.datei, Text() += dat->variablen.get(i)->debug.zeile, dat->variablen.get(i)->name }, zObj);
  1434. klassT->release();
  1435. funcT->release();
  1436. varT->release();
  1437. return 0;
  1438. }
  1439. }
  1440. for (int i = 0; i < kAnz; i++)
  1441. {
  1442. if (!compileKlasse(dat->klassen.get(i), klassT))
  1443. {
  1444. klassT->release();
  1445. funcT->release();
  1446. varT->release();
  1447. return 0;
  1448. }
  1449. }
  1450. for (int i = 0; i < vAnz; i++)
  1451. {
  1452. KSGSVariableDef* k = compileVariable(dat->variablen.get(i), klassT, i);
  1453. if (!k)
  1454. {
  1455. int anz = variablen->getEintragAnzahl();
  1456. for (int i = 0; i < anz; i++)
  1457. delete variablen->get(i);
  1458. variablen->leeren();
  1459. klassT->release();
  1460. funcT->release();
  1461. varT->release();
  1462. return 0;
  1463. }
  1464. variablen->add(k);
  1465. }
  1466. for (int i = 0; i < kAnz; i++)
  1467. {
  1468. KSGSKlasse* k = buildKlasse(dat->klassen.get(i), klassT, funcT, varT);
  1469. if (!k)
  1470. {
  1471. klassen->leeren();
  1472. variablen->leeren();
  1473. klassT->release();
  1474. funcT->release();
  1475. varT->release();
  1476. return 0;
  1477. }
  1478. klassen->add(k);
  1479. }
  1480. funktionen->add(new KSGSCallbackFunktion());
  1481. for (int i = 0; i < fAnz; i++)
  1482. {
  1483. KSGSFunktion* f = buildFunktion(dat->funktionen.get(i), klassT, funcT, varT);
  1484. if (!f)
  1485. {
  1486. klassen->leeren();
  1487. funktionen->leeren();
  1488. variablen->leeren();
  1489. klassT->release();
  1490. funcT->release();
  1491. varT->release();
  1492. return 0;
  1493. }
  1494. funktionen->add(f);
  1495. }
  1496. klassT->release();
  1497. funcT->release();
  1498. varT->release();
  1499. return 1;
  1500. }
  1501. // constant
  1502. int KSGSLeser::getMainFuncId() const
  1503. {
  1504. return mainFuncId;
  1505. }
  1506. int KSGSLeser::getMausFuncId() const
  1507. {
  1508. return mausFuncId;
  1509. }
  1510. int KSGSLeser::getTastaturFuncId() const
  1511. {
  1512. return tastaturFuncId;
  1513. }
  1514. int KSGSLeser::getTickFuncId() const
  1515. {
  1516. return tickFuncId;
  1517. }
  1518. int KSGSLeser::getRenderFuncId() const
  1519. {
  1520. return renderFuncId;
  1521. }