KSGSFunktion.cpp 6.2 KB

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