KSGSFunktion.cpp 5.7 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319
  1. #include "KSGSFunktion.h"
  2. #include "../Leser/KSGSLeser.h"
  3. #include "../Main/KSGScriptObj.h"
  4. #include "../Klassen/KSGSThread.h"
  5. #include "../Error/Error.h"
  6. #include "../Klassen/KSGSTyp.h"
  7. #include <iostream>
  8. using namespace KSGScript;
  9. // Inhalt der KSGSFunktionInstanz Klasse aus KSGSFunktion.h
  10. // Konstruktor
  11. KSGSFunktionInstanz::KSGSFunktionInstanz( RCArray< KSGSBefehl > *ba, int rt, KSGScriptObj *obj, KSGSKlasseInstanz *klasse )
  12. : Thread()
  13. {
  14. lokaleVariablen = new RCArray< KSGSVariable >();
  15. befehle = ba;
  16. this->klasse = klasse;
  17. this->obj = obj;
  18. threadVar = 0;
  19. returnTyp = rt;
  20. retVar = 0;
  21. pausiert = 0;
  22. beendet = 0;
  23. breakB = 0;
  24. continueB = 0;
  25. scrId = obj->getScriptId();
  26. ref = 1;
  27. }
  28. // Destruktor
  29. KSGSFunktionInstanz::~KSGSFunktionInstanz()
  30. {
  31. lokaleVariablen->release();
  32. befehle->release();
  33. if( klasse )
  34. klasse->release();
  35. obj->release();
  36. if( threadVar )
  37. threadVar->release();
  38. if( retVar )
  39. retVar->release();
  40. }
  41. // privat
  42. void KSGSFunktionInstanz::lock()
  43. {
  44. cs.lock();
  45. }
  46. void KSGSFunktionInstanz::unlock()
  47. {
  48. cs.unlock();
  49. }
  50. // nicht constant
  51. void KSGSFunktionInstanz::setParameter( Array< KSGSVariableDef* > *zDef, RCArray< KSGSVariable > *vars )
  52. {
  53. int anz = zDef->getEintragAnzahl();
  54. for( int i = 0; i < anz; i++ )
  55. {
  56. int id = zDef->get( i )->id;
  57. if( vars->z( id ) )
  58. {
  59. if( zDef->get( i )->typId != vars->z( id )->getTyp() )
  60. {
  61. KSGSVariable *var = vars->z( id )->umwandelnIn( zDef->get( i )->typId );
  62. if( !var )
  63. lokaleVariablen->set( KSGSVariable::erstellVariable( obj, zDef->get( i ) ), id );
  64. else
  65. lokaleVariablen->set( var, id );
  66. }
  67. else
  68. lokaleVariablen->set( vars->get( id ), id );
  69. }
  70. else
  71. lokaleVariablen->set( KSGSVariable::erstellVariable( obj, zDef->get( i ) ), id );
  72. }
  73. vars->release();
  74. }
  75. void KSGSFunktionInstanz::setReturnVariable( KSGSVariable *var )
  76. {
  77. if( var->getTyp() != returnTyp )
  78. {
  79. error( 15, {}, obj );
  80. KSGSVariable *tmp = var->umwandelnIn( returnTyp );
  81. var->release();
  82. var = tmp;
  83. }
  84. lock();
  85. if( retVar )
  86. retVar->release();
  87. retVar = var;
  88. unlock();
  89. }
  90. void KSGSFunktionInstanz::setPause( bool p )
  91. {
  92. pausiert = p;
  93. }
  94. void KSGSFunktionInstanz::setContinue()
  95. {
  96. continueB = 1;
  97. }
  98. void KSGSFunktionInstanz::setBreak()
  99. {
  100. breakB = 0;
  101. }
  102. void KSGSFunktionInstanz::setEnde()
  103. {
  104. beendet = 1;
  105. }
  106. KSGSVariable *KSGSFunktionInstanz::startFunktion()
  107. {
  108. if( run )
  109. return 0;
  110. if( threadVar )
  111. threadVar = (KSGSThreadKlasse*)threadVar->release();
  112. if( retVar )
  113. retVar = retVar->release();
  114. if( returnTyp == KSGS_THREAD )
  115. {
  116. threadVar = new KSGSThreadKlasse( obj, getThis() );
  117. start();
  118. return threadVar->getThis();
  119. }
  120. else
  121. {
  122. run = 1;
  123. thread();
  124. warteAufFunktion( INFINITE );
  125. return retVar ? retVar->getThis() : 0;
  126. }
  127. }
  128. void KSGSFunktionInstanz::thread()
  129. {
  130. getThis();
  131. int anz = befehle->getEintragAnzahl();
  132. for( int i = 0; i < anz; i++ )
  133. {
  134. while( pausiert && !beendet && !obj->istBeendet( scrId ) )
  135. Sleep( 100 );
  136. if( obj->istBeendet( scrId ) || beendet )
  137. break;
  138. KSGSBefehl *b = befehle->z( i );
  139. if( b )
  140. {
  141. KSGSVariable *var = b->ausführen( obj, this, klasse );
  142. if( var )
  143. var->release();
  144. }
  145. }
  146. run = 0;
  147. if( threadVar )
  148. {
  149. threadVar->threadEnde();
  150. threadVar = (KSGSThreadKlasse*)threadVar->release();
  151. }
  152. release();
  153. }
  154. int KSGSFunktionInstanz::getStatus()
  155. {
  156. if( !isRunning() || beendet )
  157. return 0;
  158. if( pausiert )
  159. return 1;
  160. if( breakB )
  161. {
  162. breakB = 0;
  163. return 2;
  164. }
  165. if( continueB )
  166. {
  167. continueB = 0;
  168. return 3;
  169. }
  170. return 4;
  171. }
  172. void KSGSFunktionInstanz::setVariable( int id, KSGSVariable *var )
  173. {
  174. lokaleVariablen->set( var, id );
  175. }
  176. // constant
  177. KSGSVariable *KSGSFunktionInstanz::getVariable( int id ) const
  178. {
  179. return lokaleVariablen->get( id );
  180. }
  181. int KSGSFunktionInstanz::getReturnTyp() const
  182. {
  183. return returnTyp;
  184. }
  185. bool KSGSFunktionInstanz::wirdFunktionAusgeführt() const
  186. {
  187. return isRunning();
  188. }
  189. int KSGSFunktionInstanz::warteAufFunktion( int zeit )
  190. {
  191. if( run )
  192. return warteAufThread( zeit );
  193. return 0;
  194. }
  195. bool KSGSFunktionInstanz::wirdAusgeführt() const
  196. {
  197. return isRunning() && !beendet && !pausiert;
  198. }
  199. // Reference Counting
  200. KSGSFunktionInstanz *KSGSFunktionInstanz::getThis()
  201. {
  202. ref++;
  203. return this;
  204. }
  205. KSGSFunktionInstanz *KSGSFunktionInstanz::release()
  206. {
  207. ref--;
  208. if( !ref )
  209. delete this;
  210. return 0;
  211. }
  212. // Inhalt der KSGSFunktion Klasse aus KSGSFunktion.h
  213. // Konstruktor
  214. KSGSFunktion::KSGSFunktion( int id, int sichtbar, int typ )
  215. : typId( typ ),
  216. sichtbar( sichtbar ),
  217. id( id ),
  218. ref( 1 )
  219. {
  220. befehle = new RCArray< KSGSBefehl >();
  221. parameter = new Array< KSGSVariableDef* >();
  222. name = "";
  223. }
  224. // Destruktor
  225. KSGSFunktion::~KSGSFunktion()
  226. {
  227. if( befehle )
  228. befehle->release();
  229. int anz = parameter->getEintragAnzahl();
  230. for( int i = 0; i < anz; i++ )
  231. delete parameter->get( i );
  232. if( parameter )
  233. parameter->release();
  234. }
  235. // nicht constant
  236. void KSGSFunktion::setName( const char *txt )
  237. {
  238. name = txt;
  239. }
  240. void KSGSFunktion::addParameter( KSGSVariableDef *var )
  241. {
  242. parameter->add( var );
  243. }
  244. void KSGSFunktion::addBefehl( KSGSBefehl *befehl )
  245. {
  246. befehle->add( befehl );
  247. }
  248. KSGSFunktionInstanz *KSGSFunktion::erstellInstanz( KSGScriptObj *obj, KSGSKlasseInstanz *klasse, RCArray< KSGSVariable > *params )
  249. {
  250. KSGSFunktionInstanz *inst = new KSGSFunktionInstanz( befehle->getThis(), typId, obj, klasse );
  251. if( params )
  252. inst->setParameter( parameter, params );
  253. return inst;
  254. }
  255. // constant
  256. int KSGSFunktion::getId() const
  257. {
  258. return id;
  259. }
  260. int KSGSFunktion::getTypId() const
  261. {
  262. return typId;
  263. }
  264. int KSGSFunktion::getSichtbarkeit() const
  265. {
  266. return sichtbar;
  267. }
  268. bool KSGSFunktion::hatName( const char *txt ) const
  269. {
  270. return name.istGleich( txt );
  271. }
  272. // Reference Counting
  273. KSGSFunktion *KSGSFunktion::getThis()
  274. {
  275. ref++;
  276. return this;
  277. }
  278. KSGSFunktion *KSGSFunktion::release()
  279. {
  280. ref--;
  281. if( !ref )
  282. delete this;
  283. return 0;
  284. }