KSGSLeser.cpp 43 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/KSGSRückruf.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_GRÖßERGLEICH;
  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_GRÖßER;
  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 *län )
  105. {
  106. *län = 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. *län = 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. *län = 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 län = (int)( endPos - d->getLPosition() );
  985. if( län )
  986. {
  987. char *txt = new char[ län + 1 ];
  988. txt[ län ] = 0;
  989. d->lese( txt, län );
  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 län = (int)( endPos - d->getLPosition() );
  1012. if( län )
  1013. {
  1014. char *txt = new char[ län + 1 ];
  1015. txt[ län ] = 0;
  1016. d->lese( txt, län );
  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 län = (int)( endPos - d->getLPosition() );
  1104. if( län )
  1105. {
  1106. char *txt = new char[ län + 1 ];
  1107. txt[ län ] = 0;
  1108. d->lese( txt, län );
  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 län = (int)( endPos - d->getLPosition() );
  1146. if( län )
  1147. {
  1148. char *txt = new char[ län + 1 ];
  1149. txt[ län ] = 0;
  1150. d->lese( txt, län );
  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( (char *)zLK->name ) )
  1188. {
  1189. error( 10, {}, zObj );
  1190. return 0;
  1191. }
  1192. KSGSCompileKlasse *k = zKT->get( (char *)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( (char *)zLK->variablen.get( i )->typ );
  1204. if( !tmp )
  1205. {
  1206. error( 11, { zLK->debug.datei, Text() += zLK->debug.zeile, (char *)zLK->variablen.get( i )->typ, (char *)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( (char *)zLF->typ )->id, s, {} );
  1220. int anz = zLF->parameter.getEintragAnzahl();
  1221. for( int j = 0; j < anz; j++ )
  1222. {
  1223. auto tmp = zKT->get( (char *)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( (char *)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( (char *)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( (char *)zLK->name ) )
  1256. {
  1257. error( 10, {}, zObj );
  1258. return 0;
  1259. }
  1260. KSGSKlasse *ret = new KSGSKlasse( zKT->get( (char *)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( (char *)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( (char *)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( (char *)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( (char *)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 KSGSRückrufFunktion() );
  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. }