KSGSFunktion.cpp 6.1 KB

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