javaembed.cpp 149 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029203020312032203320342035203620372038203920402041204220432044204520462047204820492050205120522053205420552056205720582059206020612062206320642065206620672068206920702071207220732074207520762077207820792080208120822083208420852086208720882089209020912092209320942095209620972098209921002101210221032104210521062107210821092110211121122113211421152116211721182119212021212122212321242125212621272128212921302131213221332134213521362137213821392140214121422143214421452146214721482149215021512152215321542155215621572158215921602161216221632164216521662167216821692170217121722173217421752176217721782179218021812182218321842185218621872188218921902191219221932194219521962197219821992200220122022203220422052206220722082209221022112212221322142215221622172218221922202221222222232224222522262227222822292230223122322233223422352236223722382239224022412242224322442245224622472248224922502251225222532254225522562257225822592260226122622263226422652266226722682269227022712272227322742275227622772278227922802281228222832284228522862287228822892290229122922293229422952296229722982299230023012302230323042305230623072308230923102311231223132314231523162317231823192320232123222323232423252326232723282329233023312332233323342335233623372338233923402341234223432344234523462347234823492350235123522353235423552356235723582359236023612362236323642365236623672368236923702371237223732374237523762377237823792380238123822383238423852386238723882389239023912392239323942395239623972398239924002401240224032404240524062407240824092410241124122413241424152416241724182419242024212422242324242425242624272428242924302431243224332434243524362437243824392440244124422443244424452446244724482449245024512452245324542455245624572458245924602461246224632464246524662467246824692470247124722473247424752476247724782479248024812482248324842485248624872488248924902491249224932494249524962497249824992500250125022503250425052506250725082509251025112512251325142515251625172518251925202521252225232524252525262527252825292530253125322533253425352536253725382539254025412542254325442545254625472548254925502551255225532554255525562557255825592560256125622563256425652566256725682569257025712572257325742575257625772578257925802581258225832584258525862587258825892590259125922593259425952596259725982599260026012602260326042605260626072608260926102611261226132614261526162617261826192620262126222623262426252626262726282629263026312632263326342635263626372638263926402641264226432644264526462647264826492650265126522653265426552656265726582659266026612662266326642665266626672668266926702671267226732674267526762677267826792680268126822683268426852686268726882689269026912692269326942695269626972698269927002701270227032704270527062707270827092710271127122713271427152716271727182719272027212722272327242725272627272728272927302731273227332734273527362737273827392740274127422743274427452746274727482749275027512752275327542755275627572758275927602761276227632764276527662767276827692770277127722773277427752776277727782779278027812782278327842785278627872788278927902791279227932794279527962797279827992800280128022803280428052806280728082809281028112812281328142815281628172818281928202821282228232824282528262827282828292830283128322833283428352836283728382839284028412842284328442845284628472848284928502851285228532854285528562857285828592860286128622863286428652866286728682869287028712872287328742875287628772878287928802881288228832884288528862887288828892890289128922893289428952896289728982899290029012902290329042905290629072908290929102911291229132914291529162917291829192920292129222923292429252926292729282929293029312932293329342935293629372938293929402941294229432944294529462947294829492950295129522953295429552956295729582959296029612962296329642965296629672968296929702971297229732974297529762977297829792980298129822983298429852986298729882989299029912992299329942995299629972998299930003001300230033004300530063007300830093010301130123013301430153016301730183019302030213022302330243025302630273028302930303031303230333034303530363037303830393040304130423043304430453046304730483049305030513052305330543055305630573058305930603061306230633064306530663067306830693070307130723073307430753076307730783079308030813082308330843085308630873088308930903091309230933094309530963097309830993100310131023103310431053106310731083109311031113112311331143115311631173118311931203121312231233124312531263127312831293130313131323133313431353136313731383139314031413142314331443145314631473148314931503151315231533154315531563157315831593160316131623163316431653166316731683169317031713172317331743175317631773178317931803181318231833184318531863187318831893190319131923193319431953196319731983199320032013202320332043205320632073208320932103211321232133214321532163217321832193220322132223223322432253226322732283229323032313232323332343235323632373238323932403241324232433244324532463247324832493250325132523253325432553256325732583259326032613262326332643265326632673268326932703271327232733274327532763277327832793280328132823283328432853286328732883289329032913292329332943295329632973298329933003301330233033304330533063307330833093310331133123313331433153316331733183319332033213322332333243325332633273328332933303331333233333334333533363337333833393340334133423343334433453346334733483349335033513352335333543355335633573358335933603361336233633364336533663367336833693370337133723373337433753376337733783379338033813382338333843385338633873388338933903391339233933394339533963397339833993400340134023403340434053406340734083409341034113412341334143415341634173418341934203421342234233424342534263427342834293430343134323433343434353436343734383439344034413442344334443445344634473448344934503451345234533454345534563457345834593460346134623463346434653466346734683469347034713472347334743475347634773478347934803481348234833484348534863487348834893490349134923493349434953496349734983499350035013502350335043505350635073508350935103511351235133514351535163517351835193520352135223523352435253526352735283529353035313532353335343535353635373538353935403541354235433544354535463547354835493550355135523553355435553556355735583559356035613562356335643565356635673568356935703571357235733574357535763577357835793580358135823583358435853586358735883589359035913592359335943595359635973598359936003601360236033604360536063607360836093610361136123613361436153616361736183619362036213622362336243625362636273628362936303631363236333634363536363637363836393640364136423643364436453646364736483649365036513652365336543655365636573658365936603661366236633664366536663667366836693670367136723673367436753676367736783679368036813682368336843685368636873688368936903691369236933694369536963697369836993700370137023703370437053706370737083709371037113712371337143715371637173718371937203721372237233724372537263727372837293730373137323733373437353736373737383739374037413742374337443745374637473748374937503751375237533754375537563757375837593760376137623763376437653766376737683769377037713772377337743775377637773778377937803781378237833784378537863787378837893790379137923793379437953796379737983799380038013802380338043805380638073808380938103811381238133814381538163817381838193820382138223823382438253826382738283829383038313832383338343835383638373838383938403841384238433844384538463847384838493850385138523853385438553856385738583859386038613862386338643865386638673868386938703871387238733874387538763877387838793880388138823883388438853886388738883889389038913892389338943895389638973898389939003901390239033904390539063907390839093910391139123913391439153916391739183919392039213922392339243925392639273928392939303931393239333934393539363937393839393940394139423943394439453946394739483949395039513952395339543955395639573958395939603961396239633964396539663967396839693970397139723973397439753976397739783979398039813982398339843985398639873988398939903991399239933994399539963997399839994000400140024003400440054006400740084009401040114012401340144015401640174018401940204021402240234024402540264027402840294030403140324033403440354036403740384039404040414042404340444045404640474048404940504051405240534054405540564057405840594060406140624063406440654066406740684069407040714072407340744075407640774078407940804081408240834084408540864087408840894090409140924093409440954096409740984099410041014102410341044105410641074108410941104111411241134114411541164117411841194120
  1. /*##############################################################################
  2. HPCC SYSTEMS software Copyright (C) 2012 HPCC Systems®.
  3. Licensed under the Apache License, Version 2.0 (the "License");
  4. you may not use this file except in compliance with the License.
  5. You may obtain a copy of the License at
  6. http://www.apache.org/licenses/LICENSE-2.0
  7. Unless required by applicable law or agreed to in writing, software
  8. distributed under the License is distributed on an "AS IS" BASIS,
  9. WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  10. See the License for the specific language governing permissions and
  11. limitations under the License.
  12. ############################################################################## */
  13. #include "platform.h"
  14. #include <jni.h>
  15. #include "jexcept.hpp"
  16. #include "jthread.hpp"
  17. #include "junicode.hpp"
  18. #include "hqlplugins.hpp"
  19. #include "deftype.hpp"
  20. #include "eclhelper.hpp"
  21. #include "eclrtl.hpp"
  22. #include "eclrtl_imp.hpp"
  23. #include "rtlfield.hpp"
  24. #include "rtlds_imp.hpp"
  25. #include "jprop.hpp"
  26. #include "build-config.h"
  27. #include "roxiemem.hpp"
  28. #include "nbcd.hpp"
  29. #include "rtlformat.hpp"
  30. #include "esdl_def.hpp"
  31. #include "enginecontext.hpp"
  32. #ifndef _WIN32
  33. #include <sys/resource.h>
  34. #endif
  35. static const char * compatibleVersions[] = {
  36. "Java Embed Helper 1.0.0",
  37. NULL };
  38. static const char *version = "Java Embed Helper 1.0.0";
  39. #ifdef _DEBUG
  40. //#define TRACE_CLASSFILE
  41. //#define CHECK_JNI
  42. /* Note - if you enable CHECK_JNI and see output like:
  43. * WARNING in native method: JNI call made without checking exceptions when required to from CallObjectMethodV
  44. * where for 'from' may be any of several functions, then the cause is likely to be a missing call to checkException()
  45. * after a call to the named function. One way to find the responsible call is with a breakpoint on checked_jni_CallObjectMethodV
  46. * The last time that breakpoint is hit before the warning is given should have a stack trace that tells you all you need to know.
  47. */
  48. #endif
  49. extern "C" DECL_EXPORT bool getECLPluginDefinition(ECLPluginDefinitionBlock *pb)
  50. {
  51. if (pb->size == sizeof(ECLPluginDefinitionBlockEx))
  52. {
  53. ECLPluginDefinitionBlockEx * pbx = (ECLPluginDefinitionBlockEx *) pb;
  54. pbx->compatibleVersions = compatibleVersions;
  55. }
  56. else if (pb->size != sizeof(ECLPluginDefinitionBlock))
  57. return false;
  58. pb->magicVersion = PLUGIN_VERSION;
  59. pb->version = version;
  60. pb->moduleName = "java";
  61. pb->ECL = NULL;
  62. pb->flags = PLUGIN_MULTIPLE_VERSIONS;
  63. pb->description = "Java Embed Helper";
  64. return true;
  65. }
  66. __declspec(noreturn) static void UNSUPPORTED(const char *feature) __attribute__((noreturn));
  67. static void UNSUPPORTED(const char *feature)
  68. {
  69. throw MakeStringException(-1, "UNSUPPORTED feature: %s not supported in java plugin", feature);
  70. }
  71. namespace javaembed {
  72. static void checkException(JNIEnv *JNIenv, bool fail=true)
  73. {
  74. if (JNIenv->ExceptionCheck())
  75. {
  76. jthrowable exception = JNIenv->ExceptionOccurred();
  77. JNIenv->ExceptionClear();
  78. jclass throwableClass = JNIenv->FindClass("java/lang/Throwable");
  79. jmethodID throwableToString = JNIenv->GetMethodID(throwableClass, "toString", "()Ljava/lang/String;");
  80. jstring cause = (jstring) JNIenv->CallObjectMethod(exception, throwableToString);
  81. const char *text = JNIenv->GetStringUTFChars(cause, 0);
  82. VStringBuffer message("javaembed: %s", text);
  83. JNIenv->ReleaseStringUTFChars(cause, text);
  84. if (fail)
  85. rtlFail(0, message);
  86. throw MakeStringExceptionDirect(0, message);
  87. }
  88. }
  89. static void printClassForObject(JNIEnv *JNIenv, jobject obj)
  90. {
  91. jclass objClass = JNIenv->GetObjectClass(obj);
  92. checkException(JNIenv);
  93. jmethodID mid = JNIenv->GetMethodID(objClass, "getClass", "()Ljava/lang/Class;");
  94. checkException(JNIenv);
  95. jobject clsObj = JNIenv->CallObjectMethod(obj, mid);
  96. checkException(JNIenv);
  97. // Now get the class object's class descriptor
  98. jclass cls = JNIenv->GetObjectClass(clsObj);
  99. checkException(JNIenv);
  100. // Find the getName() method on the class object
  101. mid = JNIenv->GetMethodID(cls, "getName", "()Ljava/lang/String;");
  102. checkException(JNIenv);
  103. // Call the getName() to get a jstring object back
  104. jstring strObj = (jstring) JNIenv->CallObjectMethod(clsObj, mid);
  105. checkException(JNIenv);
  106. // Now get the c string from the java jstring object
  107. const char* str = JNIenv->GetStringUTFChars(strObj, NULL);
  108. // Print the class name
  109. printf("Object %p has class %s\n", obj, str);
  110. // Release the memory pinned char array
  111. JNIenv->ReleaseStringUTFChars(strObj, str);
  112. }
  113. // Use a global object to ensure that the Java VM is initialized once only.
  114. // We would like to create it lazily for two reasons:
  115. // 1. So that we only get a JVM if we need one (even if we have loaded the plugin)
  116. // 2. It's important for the JVM to be initialized AFTER we have set up signal handlers, as it
  117. // likes to set its own (in particular, it seems to intercept and ignore some SIGSEGV during the
  118. // garbage collection).
  119. // Unfortunately, it seems that the design of the JNI interface is such that JNI_CreateJavaVM has to be called on the 'main thread'.
  120. // So we can't achieve 1, and 2 requires that we create via the INIT_MODULE mechanism (rather than just a static object), and that
  121. // any engines that call InitModuleObjects() or load plugins dynamically do so AFTER setting any signal handlers or calling
  122. // EnableSEHtoExceptionMapping
  123. //
  124. static JNIEnv *queryJNIEnv();
  125. static class JavaGlobalState
  126. {
  127. public:
  128. JavaGlobalState()
  129. {
  130. JavaVMInitArgs vm_args; /* JDK/JRE 6 VM initialization arguments */
  131. StringArray optionStrings;
  132. const char* origPath = getenv("CLASSPATH");
  133. StringBuffer newPath;
  134. newPath.append("-Djava.class.path=");
  135. if (origPath && *origPath)
  136. {
  137. newPath.append(origPath).append(ENVSEPCHAR);
  138. }
  139. const IProperties &conf = queryEnvironmentConf();
  140. if (conf.hasProp("classpath"))
  141. {
  142. conf.getProp("classpath", newPath);
  143. newPath.append(ENVSEPCHAR);
  144. }
  145. else
  146. {
  147. newPath.append(INSTALL_DIR).append(PATHSEPCHAR).append("classes").append(ENVSEPCHAR);
  148. }
  149. newPath.append(".");
  150. optionStrings.append(newPath);
  151. if (conf.hasProp("jvmlibpath"))
  152. {
  153. StringBuffer libPath;
  154. libPath.append("-Djava.library.path=");
  155. conf.getProp("jvmlibpath", libPath);
  156. optionStrings.append(libPath);
  157. }
  158. // Options we should set (but allow for override with jvmoptions below)
  159. optionStrings.append("-XX:-UseLargePages");
  160. if (conf.hasProp("jvmoptions"))
  161. {
  162. // Use space as field sep as ':' and ';' are valid
  163. optionStrings.appendList(conf.queryProp("jvmoptions"), " ");
  164. }
  165. // Options we know we always want set
  166. optionStrings.append("-Xrs");
  167. #ifdef RLIMIT_STACK
  168. // JVM has a habit of reducing the stack limit on main thread to 1M - probably dates back to when it was actually an increase...
  169. StringBuffer stackOption("-Xss");
  170. struct rlimit limit;
  171. rlim_t slim = 0;
  172. if (getrlimit (RLIMIT_STACK, &limit)==0)
  173. slim = limit.rlim_cur;
  174. if (!slim)
  175. slim = 8*1024*1024;
  176. if (slim >= 1*1024*1024)
  177. {
  178. stackOption.append((__uint64) slim);
  179. optionStrings.append(stackOption);
  180. }
  181. #endif
  182. // These may be useful for debugging
  183. #ifdef CHECK_JNI
  184. optionStrings.append("-Xcheck:jni");
  185. optionStrings.append("-verbose:jni");
  186. optionStrings.append("-XX:+TraceClassLoading");
  187. #endif
  188. JavaVMOption* options = new JavaVMOption[optionStrings.length()];
  189. ForEachItemIn(idx, optionStrings)
  190. {
  191. // DBGLOG("javaembed: Setting JVM option: %s",(char *)optionStrings.item(idx));
  192. options[idx].optionString = (char *) optionStrings.item(idx);
  193. options[idx].extraInfo = NULL;
  194. }
  195. vm_args.nOptions = optionStrings.length();
  196. vm_args.options = options;
  197. vm_args.ignoreUnrecognized = true;
  198. vm_args.version = JNI_VERSION_1_8;
  199. /* load and initialize a Java VM, return a JNI interface pointer in env */
  200. JNIEnv *env; /* receives pointer to native method interface */
  201. int createResult = JNI_CreateJavaVM(&javaVM, (void**)&env, &vm_args);
  202. delete [] options;
  203. if (createResult != 0)
  204. throw MakeStringException(0, "javaembed: Unable to initialize JVM (%d)",createResult);
  205. // DBGLOG("JNI environment version %x loaded", env->GetVersion()); // Comes out a bit too early
  206. }
  207. ~JavaGlobalState()
  208. {
  209. /* We could release global persisted classes here but not a lot of point. Code would look something like this:
  210. HashIterator it(persistedObjects);
  211. ForEach(it)
  212. {
  213. IMapping &entry = it.query();
  214. jobject *pObj = persistedObjects.mapToValue(&entry);
  215. if (pClass)
  216. queryJNIEnv()->DeleteGlobalRef(*pObj);
  217. }
  218. */
  219. // We don't attempt to destroy the Java VM, as it's buggy...
  220. }
  221. jobject getGlobalObject(const char *name, JNIEnv *JNIenv, jclass javaClass, jmethodID constructor, bool &isNew)
  222. {
  223. CriticalBlock b(hashCrit);
  224. isNew = false;
  225. jobject *obj = persistedObjects.getValue(name);
  226. if (obj)
  227. return JNIenv->NewGlobalRef(*obj);
  228. isNew = true;
  229. jobject newObj = JNIenv->NewObject(javaClass, constructor);
  230. checkException(JNIenv);
  231. persistedObjects.setValue(name, JNIenv->NewGlobalRef(newObj));
  232. return JNIenv->NewGlobalRef(newObj);
  233. }
  234. void doUnregister(const char *key)
  235. {
  236. CriticalBlock b(hashCrit);
  237. jobject *obj = persistedObjects.getValue(key);
  238. if (obj)
  239. queryJNIEnv()->DeleteGlobalRef(*obj);
  240. persistedObjects.remove(key);
  241. }
  242. static void unregister(const char *key);
  243. JavaVM *javaVM; /* denotes a Java VM */
  244. private:
  245. CriticalSection hashCrit;
  246. MapStringTo<jobject> persistedObjects;
  247. } *globalState;
  248. void JavaGlobalState::unregister(const char *key)
  249. {
  250. globalState->doUnregister(key);
  251. }
  252. static StringBuffer helperLibraryName;
  253. #ifdef _WIN32
  254. EXTERN_C IMAGE_DOS_HEADER __ImageBase;
  255. #endif
  256. MODULE_INIT(INIT_PRIORITY_STANDARD)
  257. {
  258. globalState = new JavaGlobalState;
  259. // Make sure we are never unloaded (as JVM does not support it)
  260. // we do this by doing a dynamic load of the javaembed library
  261. #ifdef _WIN32
  262. char ln[_MAX_PATH];
  263. ::GetModuleFileName((HINSTANCE)&__ImageBase, ln, _MAX_PATH);
  264. if (strstr(path, "javaembed"))
  265. {
  266. HINSTANCE h = LoadSharedObject(ln, false, false);
  267. helperLibraryName.set(ln);
  268. DBGLOG("LoadSharedObject returned %p", h);
  269. }
  270. #else
  271. if (findLoadedModule(helperLibraryName, "javaembed"))
  272. {
  273. HINSTANCE h = LoadSharedObject(helperLibraryName, false, false);
  274. // Deliberately leak this handle
  275. }
  276. #endif
  277. return true;
  278. }
  279. MODULE_EXIT()
  280. {
  281. // We don't attempt to destroy the Java VM, as it's buggy...
  282. // delete globalState;
  283. // globalState = NULL;
  284. }
  285. static void checkType(type_t javatype, size32_t javasize, type_t ecltype, size32_t eclsize)
  286. {
  287. if (javatype != ecltype || javasize != eclsize)
  288. throw MakeStringException(0, "javaembed: Type mismatch"); // MORE - could provide some details!
  289. }
  290. static void forceGC(JNIEnv* JNIenv)
  291. {
  292. jclass systemClass = JNIenv->FindClass("java/lang/System");
  293. checkException(JNIenv);
  294. jmethodID systemGCMethod = JNIenv->GetStaticMethodID(systemClass, "gc", "()V");
  295. checkException(JNIenv);
  296. JNIenv->CallStaticVoidMethod(systemClass, systemGCMethod);
  297. checkException(JNIenv);
  298. }
  299. enum PersistMode
  300. {
  301. persistNone,
  302. persistThread,
  303. persistWorkunit,
  304. persistQuery,
  305. persistGlobal
  306. };
  307. static PersistMode getPersistMode(const char *val) // Could argue this should be in eclrtl.hpp
  308. {
  309. if (isEmptyString(val) || strieq(val, "none"))
  310. return persistNone;
  311. else if (strieq(val, "thread"))
  312. return persistThread;
  313. else if (strieq(val, "workunit"))
  314. return persistWorkunit;
  315. else if (strieq(val, "query"))
  316. return persistQuery;
  317. else if (strieq(val, "global"))
  318. return persistGlobal;
  319. else
  320. throw MakeStringException(MSGAUD_user, 0, "javaembed: Unrecognized persist mode %s", val);
  321. }
  322. //-------------------------------------------
  323. // A JavaObject accessor has common functionality shared by both the builders below (Java-> ECL and ECL->Java)
  324. class JavaObjectAccessor : public CInterface
  325. {
  326. protected:
  327. JavaObjectAccessor(JNIEnv *_JNIenv, const RtlFieldInfo *_outerRow, jobject _row)
  328. : JNIenv(_JNIenv), row(_row), outerRow(_outerRow), idx(0), limit(0), inSet(false), inDataSet(false)
  329. {
  330. Class = (jclass) JNIenv->NewGlobalRef(JNIenv->GetObjectClass(row));
  331. }
  332. JavaObjectAccessor(JNIEnv *_JNIenv, const RtlFieldInfo *_outerRow, jclass _Class)
  333. : JNIenv(_JNIenv), outerRow(_outerRow), idx(0), limit(0), inSet(false), inDataSet(false)
  334. {
  335. row = NULL;
  336. Class = (jclass) JNIenv->NewGlobalRef(_Class);
  337. }
  338. ~JavaObjectAccessor()
  339. {
  340. // Unwind anything left on the stack (in case we had exceptions), to make sure the Class we release is the global one
  341. if (stack.length())
  342. Class = (jclass) stack.item(0);
  343. if (Class)
  344. JNIenv->DeleteGlobalRef(Class);
  345. }
  346. void push()
  347. {
  348. stack.append(Class);
  349. stack.append(row);
  350. }
  351. void pop()
  352. {
  353. row = (jobject) stack.popGet();
  354. Class = (jclass) stack.popGet();
  355. }
  356. jfieldID getFieldId(const RtlFieldInfo * field, const char *sig, const char *expected)
  357. {
  358. // MORE - if we are going to stream a dataset we really should be caching these somehow
  359. JNIenv->ExceptionClear();
  360. jfieldID fieldId = 0;
  361. if (sig)
  362. {
  363. if (inSet)
  364. {
  365. VStringBuffer arraySig("[%s", sig);
  366. fieldId = JNIenv->GetFieldID(Class, field->name, arraySig.str());
  367. }
  368. else
  369. fieldId = JNIenv->GetFieldID(Class, field->name, sig);
  370. }
  371. else
  372. {
  373. // Do it the hard way via reflection API
  374. // Equivalent java:
  375. // Field field = object.getClass().getDeclaredField(fieldName);
  376. jclass classClass =JNIenv->GetObjectClass(Class);
  377. checkException();
  378. jmethodID getDeclaredField = JNIenv->GetMethodID(classClass, "getDeclaredField", "(Ljava/lang/String;)Ljava/lang/reflect/Field;" );
  379. checkException();
  380. jstring fieldName = JNIenv->NewStringUTF(field->name);
  381. checkException();
  382. jobject reflectedField = JNIenv->CallObjectMethod(Class, getDeclaredField, fieldName);
  383. checkException();
  384. fieldId = JNIenv->FromReflectedField(reflectedField);
  385. }
  386. if (!fieldId && expected)
  387. throw MakeStringException(0, "javaembed: Unable to retrieve field %s of type %s", field->name, expected);
  388. if (expected)
  389. checkException();
  390. else
  391. JNIenv->ExceptionClear();
  392. return fieldId;
  393. }
  394. void checkException()
  395. {
  396. javaembed::checkException(JNIenv);
  397. }
  398. JNIEnv *JNIenv;
  399. jobject row;
  400. const RtlFieldInfo *outerRow;
  401. jclass Class;
  402. ConstPointerArray stack;
  403. unsigned idx;
  404. UnsignedArray idxStack;
  405. unsigned limit;
  406. bool inSet;
  407. bool inDataSet;
  408. };
  409. // A JavaRowBuilder object is used to construct an ECL row from a Java object
  410. class JavaRowBuilder : public JavaObjectAccessor, implements IFieldSource
  411. {
  412. public:
  413. IMPLEMENT_IINTERFACE;
  414. JavaRowBuilder(JNIEnv *_JNIenv, const RtlFieldInfo *_outerRow, jobject _row)
  415. : JavaObjectAccessor(_JNIenv, _outerRow, _row)
  416. {
  417. }
  418. virtual bool getBooleanResult(const RtlFieldInfo *field)
  419. {
  420. jboolean b;
  421. if (inSet)
  422. {
  423. JNIenv->GetBooleanArrayRegion((jbooleanArray) row, idx, 1, &b);
  424. }
  425. else
  426. {
  427. jfieldID fieldId = getFieldId(field, "Z", "boolean");
  428. b = JNIenv->GetBooleanField(row, fieldId);
  429. }
  430. checkException();
  431. return b;
  432. }
  433. virtual void getDataResult(const RtlFieldInfo *field, size32_t &__len, void * &__result)
  434. {
  435. jbyteArray array;
  436. if (inSet)
  437. {
  438. array = (jbyteArray) JNIenv->GetObjectArrayElement((jobjectArray) row, idx);
  439. }
  440. else
  441. {
  442. jfieldID fieldId = getFieldId(field, "[B", "DATA");
  443. array = (jbyteArray) JNIenv->GetObjectField(row, fieldId);
  444. }
  445. checkException();
  446. __len = (array != NULL ? JNIenv->GetArrayLength(array) : 0);
  447. __result = (__len > 0 ? rtlMalloc(__len) : NULL);
  448. if (__result)
  449. JNIenv->GetByteArrayRegion(array, 0, __len, (jbyte *) __result);
  450. checkException();
  451. }
  452. virtual double getRealResult(const RtlFieldInfo *field)
  453. {
  454. double d;
  455. if (inSet)
  456. {
  457. float f;
  458. switch (field->size(NULL, NULL))
  459. {
  460. case 4:
  461. JNIenv->GetFloatArrayRegion((jfloatArray) row, idx, 1, &f);
  462. d = f;
  463. break;
  464. case 8:
  465. JNIenv->GetDoubleArrayRegion((jdoubleArray) row, idx, 1, &d);
  466. break;
  467. default:
  468. throwUnexpected();
  469. }
  470. }
  471. else
  472. {
  473. jfieldID fieldId;
  474. switch (field->size(NULL, NULL))
  475. {
  476. case 4:
  477. fieldId = getFieldId(field, "F", "float");
  478. d = JNIenv->GetFloatField(row, fieldId);
  479. break;
  480. case 8:
  481. fieldId = getFieldId(field, "D", "double");
  482. d = JNIenv->GetDoubleField(row, fieldId);
  483. break;
  484. default:
  485. throwUnexpected();
  486. }
  487. }
  488. checkException();
  489. return d;
  490. }
  491. virtual __int64 getSignedResult(const RtlFieldInfo *field)
  492. {
  493. __int64 ret;
  494. if (inSet)
  495. {
  496. jbyte b;
  497. jshort s;
  498. jint i;
  499. jlong l;
  500. switch (field->size(NULL, NULL))
  501. {
  502. case 1:
  503. JNIenv->GetByteArrayRegion((jbyteArray) row, idx, 1, &b);
  504. ret = b;
  505. break;
  506. case 2:
  507. JNIenv->GetShortArrayRegion((jshortArray) row, idx, 1, &s);
  508. ret = s;
  509. break;
  510. case 4:
  511. JNIenv->GetIntArrayRegion((jintArray) row, idx, 1, &i);
  512. ret = i;
  513. break;
  514. case 8:
  515. JNIenv->GetLongArrayRegion((jlongArray) row, idx, 1, &l);
  516. ret = l;
  517. break;
  518. default:
  519. UNSUPPORTED("non-standard integer sizes");
  520. }
  521. }
  522. else
  523. {
  524. jfieldID fieldId;
  525. switch (field->size(NULL, NULL))
  526. {
  527. case 1:
  528. fieldId = getFieldId(field, "B", "byte");
  529. ret = JNIenv->GetByteField(row, fieldId);
  530. break;
  531. case 2:
  532. fieldId = getFieldId(field, "S", "short");
  533. ret = JNIenv->GetShortField(row, fieldId);
  534. break;
  535. case 4:
  536. fieldId = getFieldId(field, "I", "int");
  537. ret = JNIenv->GetIntField(row, fieldId);
  538. break;
  539. case 8:
  540. fieldId = getFieldId(field, "J", "long");
  541. ret = JNIenv->GetLongField(row, fieldId);
  542. break;
  543. default:
  544. UNSUPPORTED("non-standard integer sizes");
  545. }
  546. }
  547. checkException();
  548. return ret;
  549. }
  550. virtual unsigned __int64 getUnsignedResult(const RtlFieldInfo *field)
  551. {
  552. UNSUPPORTED("unsigned fields"); // No unsigned types in Java
  553. }
  554. virtual void getStringResult(const RtlFieldInfo *field, size32_t &__len, char * &__result)
  555. {
  556. jstring result;
  557. if (inSet)
  558. {
  559. // MORE - set of string1 mapping to Java array of char ? Not sure it's worth it.
  560. result = (jstring) JNIenv->GetObjectArrayElement((jobjectArray) row, idx);
  561. }
  562. else
  563. {
  564. if (field->isFixedSize() && field->size(NULL, NULL)==1)
  565. {
  566. // See if there's a char field
  567. jfieldID charFieldId = getFieldId(field, "C", NULL);
  568. if (charFieldId)
  569. {
  570. jchar resultChar = JNIenv->GetCharField(row, charFieldId);
  571. rtlUnicodeToStrX(__len, __result, 1, &resultChar);
  572. return;
  573. }
  574. }
  575. jfieldID fieldId = getFieldId(field, "Ljava/lang/String;", "String");
  576. result = (jstring) JNIenv->GetObjectField(row, fieldId);
  577. }
  578. if (!result)
  579. {
  580. __len = 0;
  581. __result = NULL;
  582. return;
  583. }
  584. size_t size = JNIenv->GetStringUTFLength(result); // in bytes
  585. const char *text = JNIenv->GetStringUTFChars(result, NULL);
  586. size32_t chars = rtlUtf8Length(size, text);
  587. rtlUtf8ToStrX(__len, __result, chars, text);
  588. JNIenv->ReleaseStringUTFChars(result, text);
  589. JNIenv->DeleteLocalRef(result);
  590. }
  591. virtual void getUTF8Result(const RtlFieldInfo *field, size32_t &__len, char * &__result)
  592. {
  593. jstring result;
  594. if (inSet)
  595. {
  596. // MORE - set of string1 mapping to Java array of char ? Not sure it's worth it.
  597. result = (jstring) JNIenv->GetObjectArrayElement((jobjectArray) row, idx);
  598. }
  599. else
  600. {
  601. if (field->isFixedSize() && field->size(NULL, NULL)==1)
  602. {
  603. // See if there's a char field
  604. jfieldID charFieldId = getFieldId(field, "C", NULL);
  605. if (charFieldId)
  606. {
  607. jchar resultChar = JNIenv->GetCharField(row, charFieldId);
  608. rtlUnicodeToUtf8X(__len, __result, 1, &resultChar);
  609. return;
  610. }
  611. }
  612. jfieldID fieldId = getFieldId(field, "Ljava/lang/String;", "String");
  613. result = (jstring) JNIenv->GetObjectField(row, fieldId);
  614. }
  615. if (!result)
  616. {
  617. __len = 0;
  618. __result = NULL;
  619. return;
  620. }
  621. size_t size = JNIenv->GetStringUTFLength(result); // in bytes
  622. const char *text = JNIenv->GetStringUTFChars(result, NULL);
  623. size32_t chars = rtlUtf8Length(size, text);
  624. rtlUtf8ToUtf8X(__len, __result, chars, text);
  625. JNIenv->ReleaseStringUTFChars(result, text);
  626. JNIenv->DeleteLocalRef(result);
  627. }
  628. virtual void getUnicodeResult(const RtlFieldInfo *field, size32_t &__len, UChar * &__result)
  629. {
  630. jstring result;
  631. if (inSet)
  632. {
  633. // MORE - set of string1 mapping to Java array of char ? Not sure it's worth it.
  634. result = (jstring) JNIenv->GetObjectArrayElement((jobjectArray) row, idx);
  635. }
  636. else
  637. {
  638. if (field->isFixedSize() && field->size(NULL, NULL)==1)
  639. {
  640. // See if there's a char field
  641. jfieldID charFieldId = getFieldId(field, "C", NULL);
  642. if (charFieldId)
  643. {
  644. jchar resultChar = JNIenv->GetCharField(row, charFieldId);
  645. rtlUnicodeToUnicodeX(__len, __result, 1, &resultChar);
  646. return;
  647. }
  648. }
  649. jfieldID fieldId = getFieldId(field, "Ljava/lang/String;", "String");
  650. result = (jstring) JNIenv->GetObjectField(row, fieldId);
  651. }
  652. if (!result)
  653. {
  654. __len = 0;
  655. __result = NULL;
  656. return;
  657. }
  658. size_t size = JNIenv->GetStringUTFLength(result); // in bytes
  659. const char *text = JNIenv->GetStringUTFChars(result, NULL);
  660. size32_t chars = rtlUtf8Length(size, text);
  661. rtlUtf8ToUnicodeX(__len, __result, chars, text);
  662. JNIenv->ReleaseStringUTFChars(result, text);
  663. JNIenv->DeleteLocalRef(result);
  664. }
  665. virtual void getDecimalResult(const RtlFieldInfo *field, Decimal &value)
  666. {
  667. double ret = getRealResult(field);
  668. value.setReal(ret);
  669. }
  670. virtual void processBeginSet(const RtlFieldInfo * field, bool &isAll)
  671. {
  672. isAll = false; // No concept of an 'all' set in Java
  673. push();
  674. jfieldID fieldId = getFieldId(field, NULL, "object"); // We assume it will be an array, but not sure of what...
  675. row = JNIenv->GetObjectField(row, fieldId);
  676. inSet = true;
  677. idx = -1; // First call to next() increments it to 0
  678. limit = row != NULL ? JNIenv->GetArrayLength((jarray) row) : 0;
  679. checkException();
  680. }
  681. virtual bool processNextSet(const RtlFieldInfo * field)
  682. {
  683. assertex(inSet);
  684. idx++;
  685. return idx < limit;
  686. }
  687. virtual void processBeginDataset(const RtlFieldInfo * field)
  688. {
  689. push();
  690. jfieldID fieldId = getFieldId(field, NULL, "object"); // We assume it will be an array, but not sure of what...
  691. row = JNIenv->GetObjectField(row, fieldId);
  692. inDataSet = true;
  693. idx = -1; // First call to next() increments it to 0
  694. limit = row != NULL ? JNIenv->GetArrayLength((jarray) row) : 0;
  695. checkException();
  696. }
  697. virtual void processBeginRow(const RtlFieldInfo * field)
  698. {
  699. if (field != outerRow)
  700. {
  701. push();
  702. if (inDataSet)
  703. {
  704. row = JNIenv->GetObjectArrayElement((jobjectArray) row, idx);
  705. }
  706. else
  707. {
  708. jfieldID fieldId = getFieldId(field, NULL, "object");
  709. row = JNIenv->GetObjectField(row, fieldId);
  710. }
  711. if (!row)
  712. rtlFail(0, "javaembed: child dataset object should not be NULL");
  713. Class = JNIenv->GetObjectClass(row);
  714. }
  715. }
  716. virtual bool processNextRow(const RtlFieldInfo * field)
  717. {
  718. assertex(inDataSet);
  719. idx++;
  720. return idx < limit;
  721. }
  722. virtual void processEndSet(const RtlFieldInfo * field)
  723. {
  724. inSet = false;
  725. JNIenv->DeleteLocalRef(row);
  726. pop();
  727. }
  728. virtual void processEndDataset(const RtlFieldInfo * field)
  729. {
  730. inDataSet = false;
  731. JNIenv->DeleteLocalRef(row);
  732. pop();
  733. }
  734. virtual void processEndRow(const RtlFieldInfo * field)
  735. {
  736. if (field != outerRow)
  737. {
  738. JNIenv->DeleteLocalRef(row);
  739. JNIenv->DeleteLocalRef(Class);
  740. pop();
  741. }
  742. }
  743. };
  744. //-------------------------------------------
  745. // A JavaObjectBuilder object is used to construct a Java object from an ECL row
  746. class JavaObjectBuilder : public JavaObjectAccessor, implements IFieldProcessor
  747. {
  748. public:
  749. IMPLEMENT_IINTERFACE;
  750. JavaObjectBuilder(JNIEnv *_JNIenv, const RtlFieldInfo *_outerRow, jclass _Class)
  751. : JavaObjectAccessor(_JNIenv, _outerRow, _Class)
  752. {
  753. setConstructor();
  754. }
  755. virtual void processString(unsigned numchars, const char *text, const RtlFieldInfo * field)
  756. {
  757. if (field->isFixedSize() && field->size(NULL, NULL)==1 && !inSet) // SET OF STRING1 is not mapped to array of char...
  758. {
  759. // See if there's a char field
  760. jfieldID charFieldId = getFieldId(field, "C", NULL);
  761. if (charFieldId)
  762. {
  763. assertex(numchars==1);
  764. jchar c;
  765. rtlStrToUnicode(1, &c, 1, text);
  766. JNIenv->SetCharField(row, charFieldId, c);
  767. checkException();
  768. return;
  769. }
  770. }
  771. jfieldID fieldId = getFieldId(field, "Ljava/lang/String;", "String");
  772. size32_t numchars16;
  773. rtlDataAttr unicode16;
  774. rtlStrToUnicodeX(numchars16, unicode16.refustr(), numchars, text);
  775. jstring value = JNIenv->NewString(unicode16.getustr(), numchars16);
  776. checkException();
  777. if (inSet)
  778. JNIenv->SetObjectArrayElement((jobjectArray) row, idx, value);
  779. else
  780. JNIenv->SetObjectField(row, fieldId, value);
  781. JNIenv->DeleteLocalRef(value);
  782. checkException();
  783. }
  784. virtual void processBool(bool value, const RtlFieldInfo * field)
  785. {
  786. jfieldID fieldId = getFieldId(field, "Z", "boolean");
  787. JNIenv->SetBooleanField(row, fieldId, value);
  788. checkException();
  789. }
  790. virtual void processData(unsigned len, const void *value, const RtlFieldInfo * field)
  791. {
  792. jfieldID fieldId = getFieldId(field, "[B", "data");
  793. jbyteArray javaData = JNIenv->NewByteArray(len);
  794. JNIenv->SetByteArrayRegion(javaData, 0, len, (jbyte *) value);
  795. checkException();
  796. if (inSet)
  797. JNIenv->SetObjectArrayElement((jobjectArray) row, idx, javaData);
  798. else
  799. JNIenv->SetObjectField(row, fieldId, javaData);
  800. checkException();
  801. }
  802. virtual void processInt(__int64 value, const RtlFieldInfo * field)
  803. {
  804. jfieldID fieldId;
  805. switch (field->size(NULL, NULL))
  806. {
  807. case 1:
  808. fieldId = getFieldId(field, "B", "byte");
  809. JNIenv->SetByteField(row, fieldId, value);
  810. break;
  811. case 2:
  812. fieldId = getFieldId(field, "S", "short");
  813. JNIenv->SetShortField(row, fieldId, value);
  814. break;
  815. case 4:
  816. fieldId = getFieldId(field, "I", "int");
  817. JNIenv->SetIntField(row, fieldId, value);
  818. break;
  819. case 8:
  820. fieldId = getFieldId(field, "J", "long");
  821. JNIenv->SetLongField(row, fieldId, value);
  822. break;
  823. default:
  824. UNSUPPORTED("non-standard integer sizes");
  825. break;
  826. }
  827. checkException();
  828. }
  829. virtual void processUInt(unsigned __int64 value, const RtlFieldInfo * field)
  830. {
  831. UNSUPPORTED("unsigned fields"); // No unsigned types in Java
  832. }
  833. virtual void processReal(double value, const RtlFieldInfo * field)
  834. {
  835. jfieldID fieldId;
  836. switch (field->size(NULL, NULL))
  837. {
  838. case 4:
  839. fieldId = getFieldId(field, "F", "float");
  840. JNIenv->SetFloatField(row, fieldId, (float) value);
  841. break;
  842. case 8:
  843. fieldId = getFieldId(field, "D", "double");
  844. JNIenv->SetDoubleField(row, fieldId, value);
  845. break;
  846. default:
  847. throwUnexpected();
  848. }
  849. checkException();
  850. }
  851. virtual void processDecimal(const void *value, unsigned digits, unsigned precision, const RtlFieldInfo * field)
  852. {
  853. // we could map to doubles, but probably better to let the ECL programmer do that themselves
  854. UNSUPPORTED("DECIMAL fields");
  855. }
  856. virtual void processUDecimal(const void *value, unsigned digits, unsigned precision, const RtlFieldInfo * field)
  857. {
  858. UNSUPPORTED("UDECIMAL fields");
  859. }
  860. virtual void processUnicode(unsigned numchars, const UChar *text, const RtlFieldInfo * field)
  861. {
  862. jfieldID fieldId = getFieldId(field, "Ljava/lang/String;", "String");
  863. jstring value = JNIenv->NewString(text, numchars);
  864. checkException();
  865. if (inSet)
  866. JNIenv->SetObjectArrayElement((jobjectArray) row, idx, value);
  867. else
  868. JNIenv->SetObjectField(row, fieldId, value);
  869. JNIenv->DeleteLocalRef(value);
  870. checkException();
  871. }
  872. virtual void processQString(unsigned len, const char *value, const RtlFieldInfo * field)
  873. {
  874. size32_t charCount;
  875. rtlDataAttr text;
  876. rtlQStrToStrX(charCount, text.refstr(), len, value);
  877. processString(charCount, text.getstr(), field);
  878. }
  879. virtual void processUtf8(unsigned numchars, const char *text, const RtlFieldInfo * field)
  880. {
  881. jfieldID fieldId = getFieldId(field, "Ljava/lang/String;", "String");
  882. size32_t numchars16;
  883. rtlDataAttr unicode16;
  884. rtlUtf8ToUnicodeX(numchars16, unicode16.refustr(), numchars, text);
  885. jstring value = JNIenv->NewString(unicode16.getustr(), numchars16);
  886. checkException();
  887. if (inSet)
  888. JNIenv->SetObjectArrayElement((jobjectArray) row, idx, value);
  889. else
  890. JNIenv->SetObjectField(row, fieldId, value);
  891. JNIenv->DeleteLocalRef(value);
  892. checkException();
  893. }
  894. virtual bool processBeginSet(const RtlFieldInfo * field, unsigned numElems, bool isAll, const byte *data)
  895. {
  896. push();
  897. idx = 0;
  898. limit = numElems;
  899. const char *javaTypeSignature = NULL;
  900. bool processElements = false;
  901. // row needs to be created as an array of <whatever>
  902. if (isAll)
  903. UNSUPPORTED("ALL sets");
  904. const RtlTypeInfo *childType = field->type->queryChildType();
  905. jobject newRow;
  906. switch(childType->fieldType & RFTMkind)
  907. {
  908. case type_boolean:
  909. newRow = JNIenv->NewBooleanArray(numElems);
  910. JNIenv->SetBooleanArrayRegion((jbooleanArray) newRow, 0, numElems, (jboolean *) data);
  911. javaTypeSignature = "[Z";
  912. break;
  913. case type_int:
  914. if (childType->fieldType & RFTMunsigned)
  915. UNSUPPORTED("unsigned integers");
  916. switch (childType->length)
  917. {
  918. case 1:
  919. newRow = JNIenv->NewByteArray(numElems);
  920. JNIenv->SetByteArrayRegion((jbyteArray) newRow, 0, numElems, (jbyte *) data);
  921. javaTypeSignature = "[B";
  922. break;
  923. case 2:
  924. newRow = JNIenv->NewShortArray(numElems);
  925. JNIenv->SetShortArrayRegion((jshortArray) newRow, 0, numElems, (jshort *) data);
  926. javaTypeSignature = "[S";
  927. break;
  928. case 4:
  929. newRow = JNIenv->NewIntArray(numElems);
  930. JNIenv->SetIntArrayRegion((jintArray) newRow, 0, numElems, (jint *) data);
  931. javaTypeSignature = "[I";
  932. break;
  933. case 8:
  934. newRow = JNIenv->NewLongArray(numElems);
  935. JNIenv->SetLongArrayRegion((jlongArray) newRow, 0, numElems, (jlong *) data);
  936. javaTypeSignature = "[J";
  937. break;
  938. default:
  939. UNSUPPORTED("non-standard integer sizes");
  940. break;
  941. }
  942. break;
  943. case type_real:
  944. switch (childType->length)
  945. {
  946. case 4:
  947. newRow = JNIenv->NewFloatArray(numElems);
  948. JNIenv->SetFloatArrayRegion((jfloatArray) newRow, 0, numElems, (float *) data);
  949. javaTypeSignature = "[F";
  950. break;
  951. case 8:
  952. newRow = JNIenv->NewDoubleArray(numElems);
  953. JNIenv->SetDoubleArrayRegion((jdoubleArray) newRow, 0, numElems, (double *) data);
  954. javaTypeSignature = "[D";
  955. break;
  956. default:
  957. throwUnexpected();
  958. break;
  959. }
  960. break;
  961. case type_string:
  962. case type_varstring:
  963. case type_unicode:
  964. case type_utf8:
  965. newRow = JNIenv->NewObjectArray(numElems, JNIenv->FindClass("java/lang/String"), NULL);
  966. javaTypeSignature = "[Ljava/lang/String;";
  967. processElements = true;
  968. break;
  969. case type_data:
  970. newRow = JNIenv->NewObjectArray(numElems, JNIenv->FindClass("[B"), NULL);
  971. javaTypeSignature = "[[B";
  972. processElements = true;
  973. break;
  974. default:
  975. throwUnexpected();
  976. }
  977. checkException();
  978. jfieldID fieldId = getFieldId(field, javaTypeSignature, "Array");
  979. JNIenv->SetObjectField(row, fieldId, newRow);
  980. checkException();
  981. row = newRow;
  982. inSet = true;
  983. return processElements;
  984. }
  985. virtual bool processBeginDataset(const RtlFieldInfo * field, unsigned numRows)
  986. {
  987. push();
  988. idxStack.append(idx);
  989. idx = 0;
  990. inDataSet = true;
  991. // Create an empty array
  992. jfieldID childId = getFieldId( field, NULL, "RECORD");
  993. jobject newRow = NULL;
  994. if (numRows)
  995. {
  996. jclass arrayClass = getClassForChild(childId);
  997. jmethodID isArrayMethod = JNIenv->GetMethodID(JNIenv->GetObjectClass(arrayClass), "isArray", "()Z" );
  998. checkException();
  999. if (!JNIenv->CallBooleanMethod(arrayClass, isArrayMethod))
  1000. {
  1001. JNIenv->ExceptionClear();
  1002. VStringBuffer message("javaembed: Array expected for field %s", field->name);
  1003. rtlFail(0, message.str());
  1004. }
  1005. // Set up constructor etc for the child rows, so we don't do it per row
  1006. checkException();
  1007. jmethodID getTypeMethod = JNIenv->GetMethodID(JNIenv->GetObjectClass(arrayClass), "getComponentType", "()Ljava/lang/Class;" );
  1008. checkException();
  1009. Class = (jclass) JNIenv->CallObjectMethod(arrayClass, getTypeMethod);
  1010. checkException();
  1011. setConstructor();
  1012. // Now we need to create the array
  1013. newRow = JNIenv->NewObjectArray(numRows, Class, NULL);
  1014. checkException();
  1015. }
  1016. JNIenv->SetObjectField(row, childId, newRow);
  1017. checkException();
  1018. row = newRow;
  1019. return true;
  1020. }
  1021. virtual bool processBeginRow(const RtlFieldInfo * field)
  1022. {
  1023. if (field == outerRow)
  1024. row = JNIenv->NewObject(Class, constructor);
  1025. else
  1026. {
  1027. push();
  1028. stack.append(constructor);
  1029. // Now we have to create the child object
  1030. jobject newRow = NULL;
  1031. if (inDataSet)
  1032. {
  1033. newRow = JNIenv->NewObject(Class, constructor);
  1034. checkException();
  1035. JNIenv->SetObjectArrayElement((jobjectArray) row, idx++, newRow);
  1036. }
  1037. else
  1038. {
  1039. // All this is done once per dataset in the nested dataset case. But for embedded record case we have to do it here
  1040. jfieldID childId = getFieldId( field, NULL, "RECORD");
  1041. Class = getClassForChild(childId);
  1042. setConstructor();
  1043. newRow = JNIenv->NewObject(Class, constructor);
  1044. checkException();
  1045. JNIenv->SetObjectField(row, childId, newRow);
  1046. }
  1047. row = newRow;
  1048. }
  1049. checkException();
  1050. return true;
  1051. }
  1052. virtual void processEndSet(const RtlFieldInfo * field)
  1053. {
  1054. JNIenv->DeleteLocalRef(row);
  1055. checkException();
  1056. pop();
  1057. inSet = false;
  1058. }
  1059. virtual void processEndDataset(const RtlFieldInfo * field)
  1060. {
  1061. inDataSet = false;
  1062. idx = idxStack.popGet();
  1063. pop();
  1064. }
  1065. virtual void processEndRow(const RtlFieldInfo * field)
  1066. {
  1067. if (field != outerRow)
  1068. {
  1069. constructor = (jmethodID) stack.popGet();
  1070. JNIenv->DeleteLocalRef(row);
  1071. checkException();
  1072. pop();
  1073. }
  1074. }
  1075. inline jobject getObject()
  1076. {
  1077. return row;
  1078. }
  1079. protected:
  1080. jclass getClassForChild(jfieldID childId)
  1081. {
  1082. jobject reflectedField = JNIenv->ToReflectedField(Class, childId, false);
  1083. checkException();
  1084. jclass fieldClass =JNIenv->GetObjectClass(reflectedField);
  1085. checkException();
  1086. jmethodID getTypeMethod = JNIenv->GetMethodID(fieldClass, "getType", "()Ljava/lang/Class;" );
  1087. checkException();
  1088. jclass result = (jclass) JNIenv->CallObjectMethod(reflectedField, getTypeMethod);
  1089. checkException();
  1090. JNIenv->DeleteLocalRef(reflectedField);
  1091. JNIenv->DeleteLocalRef(fieldClass);
  1092. checkException();
  1093. return result;
  1094. }
  1095. void setConstructor()
  1096. {
  1097. constructor = JNIenv->GetMethodID(Class, "<init>", "()V");
  1098. if (!constructor)
  1099. {
  1100. JNIenv->ExceptionClear();
  1101. jmethodID getNameMethod = JNIenv->GetMethodID(JNIenv->GetObjectClass(Class), "getName", "()Ljava/lang/String;" );
  1102. checkException();
  1103. jstring name = (jstring) JNIenv->CallObjectMethod(Class, getNameMethod);
  1104. checkException();
  1105. const char *nameText = JNIenv->GetStringUTFChars(name, NULL);
  1106. VStringBuffer message("javaembed: no suitable constructor for class %s", nameText);
  1107. JNIenv->ReleaseStringUTFChars(name, nameText);
  1108. checkException();
  1109. rtlFail(0, message.str());
  1110. }
  1111. }
  1112. jmethodID constructor;
  1113. };
  1114. //----------------------------------------------------------------------
  1115. // Wrap an IRowStream into a Java Iterator
  1116. class ECLDatasetIterator : public CInterfaceOf<IInterface>
  1117. {
  1118. public:
  1119. ECLDatasetIterator(JNIEnv *JNIenv, const RtlTypeInfo *_typeInfo, jclass className, IRowStream * _val)
  1120. : typeInfo(_typeInfo), val(_val),
  1121. dummyField("<row>", NULL, typeInfo),
  1122. javaBuilder(JNIenv, &dummyField, className)
  1123. {
  1124. nextRead = false;
  1125. nextPending = NULL;
  1126. }
  1127. bool hasNext()
  1128. {
  1129. if (!nextRead)
  1130. {
  1131. nextPending = (const byte *) val->ungroupedNextRow();
  1132. nextRead = true;
  1133. if (!nextPending)
  1134. val->stop();
  1135. }
  1136. return nextPending != NULL;
  1137. }
  1138. jobject next()
  1139. {
  1140. if (!hasNext())
  1141. return NULL;
  1142. typeInfo->process(nextPending, nextPending, &dummyField, javaBuilder); // Creates a java object from the incoming ECL row
  1143. nextRead = false;
  1144. return javaBuilder.getObject();
  1145. }
  1146. protected:
  1147. const RtlTypeInfo *typeInfo; // Not linked (or linkable)
  1148. Linked<IRowStream> val;
  1149. RtlFieldStrInfo dummyField;
  1150. JavaObjectBuilder javaBuilder;
  1151. const byte *nextPending;
  1152. bool nextRead;
  1153. };
  1154. //-------------------------------------------
  1155. // A Java function that returns a dataset will return a JavaRowStream object that can be
  1156. // interrogated to return each row of the result in turn
  1157. static JNIEnv *queryJNIEnv();
  1158. class JavaLocalFrame
  1159. {
  1160. public:
  1161. JavaLocalFrame(JNIEnv *_JNIenv, unsigned size = 16) : JNIenv(_JNIenv)
  1162. {
  1163. JNIenv->PushLocalFrame(size);
  1164. }
  1165. ~JavaLocalFrame()
  1166. {
  1167. JNIenv->PopLocalFrame(NULL);
  1168. }
  1169. private:
  1170. JNIEnv *JNIenv;
  1171. };
  1172. class JavaRowStream : public CInterfaceOf<IRowStream>
  1173. {
  1174. public:
  1175. JavaRowStream(jobject _iterator, IEngineRowAllocator *_resultAllocator)
  1176. : resultAllocator(_resultAllocator)
  1177. {
  1178. JNIEnv *JNIenv = queryJNIEnv();
  1179. iterator = JNIenv->NewGlobalRef(_iterator);
  1180. // Note that we can't cache the JNIEnv, iterClass, or methodIds here - calls may be made on different threads (though not at the same time).
  1181. }
  1182. ~JavaRowStream()
  1183. {
  1184. stop();
  1185. }
  1186. virtual const void *nextRow()
  1187. {
  1188. if (!iterator)
  1189. return NULL;
  1190. JNIEnv *JNIenv = queryJNIEnv();
  1191. JavaLocalFrame lf(JNIenv);
  1192. // Java code would be
  1193. // if (!iterator.hasNext)
  1194. // {
  1195. // stop();
  1196. // return NULL;
  1197. // }
  1198. // result = iterator.next();
  1199. jclass iterClass =JNIenv->GetObjectClass(iterator);
  1200. javaembed::checkException(JNIenv);
  1201. jmethodID hasNextMethod = JNIenv->GetMethodID(iterClass, "hasNext", "()Z" );
  1202. javaembed::checkException(JNIenv);
  1203. jboolean hasNext = JNIenv->CallBooleanMethod(iterator, hasNextMethod);
  1204. javaembed::checkException(JNIenv);
  1205. if (!hasNext)
  1206. {
  1207. stop();
  1208. return NULL;
  1209. }
  1210. jmethodID nextMethod = JNIenv->GetMethodID(iterClass, "next", "()Ljava/lang/Object;" );
  1211. javaembed::checkException(JNIenv);
  1212. jobject result = JNIenv->CallObjectMethod(iterator, nextMethod);
  1213. javaembed::checkException(JNIenv);
  1214. RtlDynamicRowBuilder rowBuilder(resultAllocator);
  1215. const RtlTypeInfo *typeInfo = resultAllocator->queryOutputMeta()->queryTypeInfo();
  1216. assertex(typeInfo);
  1217. RtlFieldStrInfo dummyField("<row>", NULL, typeInfo);
  1218. JavaRowBuilder javaRowBuilder(queryJNIEnv(), &dummyField, result);
  1219. size32_t len = typeInfo->build(rowBuilder, 0, &dummyField, javaRowBuilder);
  1220. return rowBuilder.finalizeRowClear(len);
  1221. }
  1222. virtual void stop()
  1223. {
  1224. resultAllocator.clear();
  1225. JNIEnv *JNIenv = queryJNIEnv();
  1226. if (JNIenv)
  1227. {
  1228. if (iterator)
  1229. {
  1230. JNIenv->DeleteGlobalRef(iterator);
  1231. iterator = NULL;
  1232. }
  1233. }
  1234. }
  1235. protected:
  1236. Linked<IEngineRowAllocator> resultAllocator;
  1237. jobject iterator;
  1238. };
  1239. const char *esdl2JavaSig(IEsdlDefinition &esdl, const char *esdlType)
  1240. {
  1241. EsdlBasicElementType t = esdl.translateSimpleType(esdlType);
  1242. switch (t)
  1243. {
  1244. case ESDLT_INT16:
  1245. case ESDLT_UINT16:
  1246. return "Ljava/lang/Short;";
  1247. case ESDLT_INT32:
  1248. case ESDLT_UINT32:
  1249. return "Ljava/lang/Integer;";
  1250. case ESDLT_INT64:
  1251. case ESDLT_UINT64:
  1252. return "Ljava/math/BigInteger;";
  1253. case ESDLT_BOOL:
  1254. return "Ljava/lang/Boolean;";
  1255. case ESDLT_FLOAT:
  1256. return "Ljava/lang/Float;";
  1257. case ESDLT_DOUBLE:
  1258. return "Ljava/lang/Double;";
  1259. case ESDLT_INT8:
  1260. case ESDLT_UINT8:
  1261. case ESDLT_BYTE:
  1262. case ESDLT_UBYTE:
  1263. return "Ljava/lang/Byte;";
  1264. case ESDLT_STRING:
  1265. return "Ljava/lang/String;";
  1266. case ESDLT_UNKOWN:
  1267. case ESDLT_STRUCT:
  1268. case ESDLT_REQUEST:
  1269. case ESDLT_RESPONSE:
  1270. case ESDLT_COMPLEX:
  1271. default:
  1272. return NULL;
  1273. }
  1274. }
  1275. const char *esdl2JavaFullClassName(IEsdlDefinition &esdl, const char *esdlType)
  1276. {
  1277. EsdlBasicElementType t = esdl.translateSimpleType(esdlType);
  1278. switch (t)
  1279. {
  1280. case ESDLT_INT16:
  1281. case ESDLT_UINT16:
  1282. return "java/lang/Short";
  1283. case ESDLT_INT32:
  1284. case ESDLT_UINT32:
  1285. return "java/lang/Integer";
  1286. case ESDLT_INT64:
  1287. case ESDLT_UINT64:
  1288. return "java/math/BigInteger";
  1289. case ESDLT_BOOL:
  1290. return "java/lang/Boolean";
  1291. case ESDLT_FLOAT:
  1292. return "java/lang/Float";
  1293. case ESDLT_DOUBLE:
  1294. return "java/lang/Double";
  1295. case ESDLT_INT8:
  1296. case ESDLT_UINT8:
  1297. case ESDLT_BYTE:
  1298. case ESDLT_UBYTE:
  1299. return "java/lang/Byte";
  1300. case ESDLT_STRING:
  1301. return "java/lang/String";
  1302. case ESDLT_UNKOWN:
  1303. case ESDLT_STRUCT:
  1304. case ESDLT_REQUEST:
  1305. case ESDLT_RESPONSE:
  1306. case ESDLT_COMPLEX:
  1307. default:
  1308. return NULL;
  1309. }
  1310. }
  1311. class JavaObjectXmlWriter : public CInterface
  1312. {
  1313. public:
  1314. JavaObjectXmlWriter(JNIEnv *_JNIenv, jobject _obj, const char *_reqType, IEsdlDefinition &_esdl, const char *_esdlService, IXmlWriter &_writer)
  1315. : JNIenv(_JNIenv), obj(_obj), writer(_writer), esdl(_esdl), esdlService(_esdlService), reqType(_reqType)
  1316. {
  1317. Class = (jclass) JNIenv->NewGlobalRef(JNIenv->GetObjectClass(obj));
  1318. langObjectClass = FindClass("java/lang/Object");
  1319. objToString = JNIenv->GetMethodID(langObjectClass, "toString", "()Ljava/lang/String;");
  1320. }
  1321. ~JavaObjectXmlWriter()
  1322. {
  1323. if (Class)
  1324. JNIenv->DeleteGlobalRef(Class);
  1325. HashIterator it(javaClasses);
  1326. ForEach(it)
  1327. {
  1328. IMapping &entry = it.query();
  1329. jclass *pClass = javaClasses.mapToValue(&entry);
  1330. if (pClass)
  1331. JNIenv->DeleteGlobalRef(*pClass);
  1332. }
  1333. }
  1334. void writeSimpleType(const char *fieldname, jobject fieldObj)
  1335. {
  1336. jstring fieldStr = (jstring) JNIenv->CallObjectMethod(fieldObj, objToString);
  1337. checkException();
  1338. if (!fieldStr)
  1339. return;
  1340. const char *text = JNIenv->GetStringUTFChars(fieldStr, NULL);
  1341. if (text)
  1342. writer.outputCString(text, fieldname);
  1343. JNIenv->ReleaseStringUTFChars(fieldStr, text);
  1344. JNIenv->DeleteLocalRef(fieldStr);
  1345. }
  1346. void writeSimpleType(jclass parentClass, jobject parentObject, const char *fieldname, const char *javaSig)
  1347. {
  1348. if (!fieldname || !*fieldname)
  1349. return;
  1350. if (!javaSig || !*javaSig)
  1351. return;
  1352. jfieldID fieldId = JNIenv->GetFieldID(parentClass, fieldname, javaSig);
  1353. if (!fieldId)
  1354. return;
  1355. jobject fieldObj = (jobject) JNIenv->GetObjectField(parentObject, fieldId);
  1356. if (!fieldObj)
  1357. return;
  1358. writeSimpleType(fieldname, fieldObj);
  1359. JNIenv->DeleteLocalRef(fieldObj);
  1360. }
  1361. void writeSimpleType(jclass parentClass, jobject parentObject, IEsdlDefObject &defObject)
  1362. {
  1363. const char *fieldname = defObject.queryName();
  1364. const char *javaSig = esdl2JavaSig(esdl, defObject.queryProp("type"));
  1365. writeSimpleType(parentClass, parentObject, fieldname, javaSig);
  1366. }
  1367. void writeEnumType(jclass parentClass, jobject parentObject, IEsdlDefObject &defObject)
  1368. {
  1369. const char *fieldname = defObject.queryName();
  1370. VStringBuffer javaSig("L%s/%s;", esdlService.str(), defObject.queryProp("enum_type"));
  1371. jfieldID fieldId = JNIenv->GetFieldID(parentClass, fieldname, javaSig);
  1372. checkException();
  1373. if (!fieldId)
  1374. return;
  1375. jobject fieldObj = (jobject) JNIenv->GetObjectField(parentObject, fieldId);
  1376. checkException();
  1377. if (!fieldObj)
  1378. return;
  1379. jstring fieldStr = (jstring) JNIenv->CallObjectMethod(fieldObj, objToString);
  1380. checkException();
  1381. const char *text = JNIenv->GetStringUTFChars(fieldStr, NULL);
  1382. if (text)
  1383. writer.outputCString(text, defObject.queryName());
  1384. JNIenv->ReleaseStringUTFChars(fieldStr, text);
  1385. }
  1386. void writeComplexType(jclass parentClass, jobject parentObject, IEsdlDefObject &defObject)
  1387. {
  1388. IEsdlDefStruct *defStruct = esdl.queryStruct(defObject.queryProp("complex_type"));
  1389. if (!defStruct)
  1390. return;
  1391. const char *fieldname = defObject.queryName();
  1392. VStringBuffer javaSig("L%s/%s;", esdlService.str(), defObject.queryProp("complex_type"));
  1393. jfieldID fieldId = JNIenv->GetFieldID(parentClass, fieldname, javaSig); //tbd cache this
  1394. if (!fieldId)
  1395. return;
  1396. jobject fieldObj = (jobject) JNIenv->GetObjectField(parentObject, fieldId);
  1397. if (!fieldObj)
  1398. return;
  1399. writer.outputBeginNested(fieldname, true);
  1400. writeChildren(JNIenv->GetObjectClass(fieldObj), fieldObj, defStruct);
  1401. writer.outputEndNested(fieldname);
  1402. }
  1403. void writeSimpleArray(jobjectArray arrayObj, jint count, const char *name, const char *item_tag)
  1404. {
  1405. writer.outputBeginNested(name, true);
  1406. writer.outputBeginArray(item_tag);
  1407. for (jint i=0; i < count; i++)
  1408. {
  1409. jobject elementObj = JNIenv->GetObjectArrayElement(arrayObj, i);
  1410. if(JNIenv->ExceptionOccurred())
  1411. break;
  1412. writeSimpleType(item_tag, elementObj);
  1413. JNIenv->DeleteLocalRef(elementObj);
  1414. }
  1415. writer.outputEndArray(item_tag);
  1416. writer.outputEndNested(name);
  1417. }
  1418. void writeComplexArray(jobjectArray arrayObj, jint count, const char *name, const char *item_tag, const char *itemTypeName)
  1419. {
  1420. writer.outputBeginNested(name, true);
  1421. writer.outputBeginArray(item_tag);
  1422. {
  1423. VStringBuffer javaClassName("%s/%s", esdlService.str(), itemTypeName);
  1424. jclass elementClass = FindClass(javaClassName);
  1425. if (!elementClass)
  1426. return;
  1427. IEsdlDefStruct *defStruct = esdl.queryStruct(itemTypeName);
  1428. if (!defStruct)
  1429. return;
  1430. for (jint i=0; i < count; i++)
  1431. {
  1432. jobject elementObj = JNIenv->GetObjectArrayElement(arrayObj, i);
  1433. javaembed::checkException(JNIenv, false);
  1434. writer.outputBeginNested(item_tag, true);
  1435. writeChildren(elementClass, elementObj, defStruct);
  1436. writer.outputEndNested(item_tag);
  1437. JNIenv->DeleteLocalRef(elementObj);
  1438. }
  1439. }
  1440. writer.outputEndArray(item_tag);
  1441. writer.outputEndNested(name);
  1442. }
  1443. void writeArray(jclass parentClass, jobject parentObject, IEsdlDefObject &defObject)
  1444. {
  1445. const char *itemTypeName = defObject.queryProp("type");
  1446. if (!itemTypeName)
  1447. return;
  1448. const char *item_tag = defObject.queryProp("item_tag");
  1449. if (!item_tag)
  1450. return;
  1451. const char *fieldname = defObject.queryName();
  1452. jclass arrayListClass = FindClass("java/util/ArrayList");
  1453. if (!arrayListClass)
  1454. return;
  1455. jmethodID toArrayMethod = JNIenv->GetMethodID(arrayListClass, "toArray", "()[Ljava/lang/Object;" );
  1456. if (!toArrayMethod)
  1457. return;
  1458. jfieldID fieldId = JNIenv->GetFieldID(parentClass, fieldname, "Ljava/util/ArrayList;");
  1459. if (!fieldId)
  1460. return;
  1461. jobject arrayListObj = (jobject) JNIenv->GetObjectField(parentObject, fieldId);
  1462. if (!arrayListObj)
  1463. return;
  1464. javaembed::checkException(JNIenv, false);
  1465. jobjectArray arrayObj = (jobjectArray) JNIenv->CallObjectMethod(arrayListObj, toArrayMethod);
  1466. if (arrayObj)
  1467. {
  1468. jint count = JNIenv->GetArrayLength(arrayObj);
  1469. if (count)
  1470. {
  1471. if (esdl2JavaSig(esdl, itemTypeName))
  1472. writeSimpleArray(arrayObj, count, defObject.queryName(), item_tag);
  1473. else
  1474. writeComplexArray(arrayObj, count, defObject.queryName(), item_tag, itemTypeName);
  1475. }
  1476. JNIenv->DeleteLocalRef(arrayObj);
  1477. }
  1478. JNIenv->DeleteLocalRef(arrayListObj);
  1479. }
  1480. void writeChildren(jclass javaClass, jobject javaObject, IEsdlDefStruct *defStruct)
  1481. {
  1482. Owned<IEsdlDefObjectIterator> children = defStruct->getChildren();
  1483. ForEach (*children)
  1484. {
  1485. IEsdlDefObject &child = children->query();
  1486. if (child.getEsdlType()==EsdlTypeElement)
  1487. {
  1488. if (child.hasProp("type"))
  1489. writeSimpleType(javaClass, javaObject, child);
  1490. else if (child.hasProp("complex_type"))
  1491. writeComplexType(javaClass, javaObject, child);
  1492. }
  1493. else if (child.getEsdlType()==EsdlTypeEnumRef)
  1494. {
  1495. writeEnumType(javaClass, javaObject, child);
  1496. }
  1497. else if (child.getEsdlType()==EsdlTypeArray)
  1498. {
  1499. writeArray(javaClass, javaObject, child);
  1500. }
  1501. }
  1502. }
  1503. void write()
  1504. {
  1505. IEsdlDefStruct *reqStruct = esdl.queryStruct(reqType);
  1506. const char *name = reqStruct->queryName();
  1507. writer.outputBeginNested("Response", true);
  1508. writer.outputBeginNested("Results", true);
  1509. writer.outputBeginNested("Result", true);
  1510. writer.outputBeginDataset(name, true);
  1511. writer.outputBeginArray("Row");
  1512. writer.outputBeginNested("Row", true);
  1513. writeChildren(Class, obj, reqStruct);
  1514. writer.outputEndNested("Row");
  1515. writer.outputEndArray("Row");
  1516. writer.outputEndDataset(name);
  1517. writer.outputEndNested("Result");
  1518. writer.outputEndNested("Results");
  1519. writer.outputEndNested("Response");
  1520. }
  1521. void checkException()
  1522. {
  1523. javaembed::checkException(JNIenv, false);
  1524. }
  1525. jclass FindClass(const char *name)
  1526. {
  1527. jclass *pClass = javaClasses.getValue(name);
  1528. if (pClass)
  1529. return *pClass;
  1530. jclass localClass = JNIenv->FindClass(name);
  1531. if (!localClass)
  1532. return 0;
  1533. jclass Class = (jclass) JNIenv->NewGlobalRef(localClass);
  1534. javaClasses.setValue(name, Class);
  1535. JNIenv->DeleteLocalRef(localClass);
  1536. return Class;
  1537. }
  1538. JNIEnv *JNIenv;
  1539. MapStringTo<jclass> javaClasses;
  1540. jclass Class;
  1541. jobject obj;
  1542. jclass langObjectClass;
  1543. jmethodID objToString;
  1544. IXmlWriter &writer;
  1545. IEsdlDefinition &esdl;
  1546. StringAttr reqType;
  1547. StringAttr esdlService;
  1548. };
  1549. //-------------------------------------------
  1550. // There is a singleton JavaThreadContext per thread. This handles the interaction between
  1551. // the C++ thread and the java threading library, ensuring that we register/unregister as needed,
  1552. // and that any thread_local function contexts are destroyed before we detach from the java thread
  1553. class JavaThreadContext
  1554. {
  1555. public:
  1556. JNIEnv *JNIenv; /* receives pointer to native method interface */
  1557. public:
  1558. JavaThreadContext()
  1559. {
  1560. jint res = globalState->javaVM->AttachCurrentThread((void **) &JNIenv, NULL);
  1561. assertex(res >= 0);
  1562. setThreadClassLoader(getSystemClassLoader());
  1563. }
  1564. ~JavaThreadContext()
  1565. {
  1566. // Make sure all thread-local function contexts are destroyed before we detach from
  1567. // the Java thread
  1568. contexts.kill();
  1569. // According to the Java VM 1.7 docs, "A native thread attached to
  1570. // the VM must call DetachCurrentThread() to detach itself before
  1571. // exiting."
  1572. globalState->javaVM->DetachCurrentThread();
  1573. }
  1574. jobject getSystemClassLoader()
  1575. {
  1576. JNIenv->ExceptionClear();
  1577. jclass javaLangClassLoaderClass = JNIenv->FindClass("java/lang/ClassLoader");
  1578. checkException();
  1579. jmethodID getSystemClassLoaderMethod = JNIenv->GetStaticMethodID(javaLangClassLoaderClass, "getSystemClassLoader", "()Ljava/lang/ClassLoader;");
  1580. checkException();
  1581. jobject systemClassLoaderObj = JNIenv->CallStaticObjectMethod(javaLangClassLoaderClass, getSystemClassLoaderMethod);
  1582. checkException();
  1583. assertex(systemClassLoaderObj);
  1584. return systemClassLoaderObj;
  1585. }
  1586. void setThreadClassLoader(jobject classLoader)
  1587. {
  1588. JNIenv->ExceptionClear();
  1589. jclass javaLangThreadClass = JNIenv->FindClass("java/lang/Thread");
  1590. checkException();
  1591. jmethodID currentThreadMethod = JNIenv->GetStaticMethodID(javaLangThreadClass, "currentThread", "()Ljava/lang/Thread;");
  1592. checkException();
  1593. jobject threadObj = JNIenv->CallStaticObjectMethod(javaLangThreadClass, currentThreadMethod);
  1594. checkException();
  1595. jmethodID setContextClassLoaderMethod = JNIenv->GetMethodID(javaLangThreadClass, "setContextClassLoader", "(Ljava/lang/ClassLoader;)V");
  1596. checkException();
  1597. JNIenv->CallObjectMethod(threadObj, setContextClassLoaderMethod, classLoader);
  1598. checkException();
  1599. }
  1600. jobject getThreadClassLoader()
  1601. {
  1602. JNIenv->ExceptionClear();
  1603. jclass javaLangThreadClass = JNIenv->FindClass("java/lang/Thread");
  1604. checkException();
  1605. jmethodID currentThreadMethod = JNIenv->GetStaticMethodID(javaLangThreadClass, "currentThread", "()Ljava/lang/Thread;");
  1606. checkException();
  1607. jobject threadObj = JNIenv->CallStaticObjectMethod(javaLangThreadClass, currentThreadMethod);
  1608. checkException();
  1609. jmethodID getContextClassLoaderMethod = JNIenv->GetMethodID(javaLangThreadClass, "getContextClassLoader", "()Ljava/lang/ClassLoader;");
  1610. checkException();
  1611. jobject contextClassLoaderObj = JNIenv->CallObjectMethod(threadObj, getContextClassLoaderMethod);
  1612. checkException();
  1613. assertex(contextClassLoaderObj);
  1614. return contextClassLoaderObj;
  1615. }
  1616. void writeObjectResult(jobject result, IEsdlDefinition *esdl, const char *esdlservice, const char *name, IXmlWriter *writer)
  1617. {
  1618. JavaObjectXmlWriter x(JNIenv, result, name, *esdl, esdlservice, *writer);
  1619. x.write();
  1620. }
  1621. void registerContext(IEmbedFunctionContext *ctx)
  1622. {
  1623. // Note - this object is thread-local so no need for a critsec
  1624. contexts.append(*ctx);
  1625. }
  1626. private:
  1627. inline void checkException()
  1628. {
  1629. javaembed::checkException(JNIenv);
  1630. }
  1631. IArrayOf<IEmbedFunctionContext> contexts;
  1632. };
  1633. class JavaXmlBuilder : implements IXmlWriterExt, public CInterface
  1634. {
  1635. public:
  1636. IMPLEMENT_IINTERFACE;
  1637. JavaXmlBuilder(JNIEnv *_JNIenv, IEsdlDefinition *esdl_, const char *esdlservice, const char *esdltype_)
  1638. : JNIenv(_JNIenv), esdl(esdl_), javaPackage(esdlservice), esdlType(esdltype_)
  1639. {
  1640. }
  1641. ~JavaXmlBuilder()
  1642. {
  1643. while (defStack.length())
  1644. popDefStackEntry(JNIenv);
  1645. HashIterator it(javaClasses);
  1646. ForEach(it)
  1647. {
  1648. IMapping &entry = it.query();
  1649. jclass *pClass = javaClasses.mapToValue(&entry);
  1650. if (pClass)
  1651. JNIenv->DeleteGlobalRef(*pClass);
  1652. }
  1653. }
  1654. void checkException()
  1655. {
  1656. javaembed::checkException(JNIenv, false);
  1657. }
  1658. void initWriter()
  1659. {
  1660. }
  1661. IXmlWriterExt & clear()
  1662. {
  1663. throwUnexpected();
  1664. }
  1665. virtual size32_t length() const
  1666. {
  1667. return 0;
  1668. }
  1669. virtual const char *str() const
  1670. {
  1671. throwUnexpected();
  1672. }
  1673. virtual void finalize() override
  1674. {
  1675. }
  1676. virtual IInterface *saveLocation() const {return nullptr;}
  1677. virtual void rewindTo(IInterface *loc)
  1678. {
  1679. //needs to be a no-op because it is used, but the way its used to trim empty xml sections I think we're fairly safe.
  1680. //revisit cleaning up any empty objects later.
  1681. }
  1682. inline IEsdlDefStruct *queryCurrentEsdlStruct()
  1683. {
  1684. if (!defStack.length() || !defStack.tos().defType)
  1685. return NULL;
  1686. return dynamic_cast<IEsdlDefStruct*>(defStack.tos().defType.get());
  1687. }
  1688. inline jobject getObject()
  1689. {
  1690. if (!defStack.length())
  1691. return 0;
  1692. return defStack.item(0).obj;
  1693. }
  1694. inline jobject getCurJavaObject()
  1695. {
  1696. if (!defStack.length())
  1697. return 0;
  1698. return defStack.tos().obj;
  1699. }
  1700. inline jclass getCurJavaClass()
  1701. {
  1702. if (!defStack.length())
  1703. return 0;
  1704. return defStack.tos().Class;
  1705. }
  1706. inline jmethodID getCurJavaConstructor()
  1707. {
  1708. if (!defStack.length())
  1709. return 0;
  1710. return defStack.tos().constructor;
  1711. }
  1712. virtual void outputEnumString(unsigned size, const char *text, const char *fieldname, IEsdlDefObject *defField)
  1713. {
  1714. const char *enum_type = defField->queryProp("enum_type");
  1715. if (!enum_type || !*enum_type)
  1716. return;
  1717. VStringBuffer enumClassName("%s/%s", javaPackage.str(), enum_type);
  1718. VStringBuffer enumSig("L%s;", enumClassName.str());
  1719. jfieldID fieldId = JNIenv->GetFieldID(getCurJavaClass(), fieldname, enumSig);
  1720. if (!fieldId)
  1721. return;
  1722. jclass enumClass = FindClass(enumClassName);
  1723. jmethodID fromString = JNIenv->GetStaticMethodID(enumClass, "fromString", "(Ljava/lang/String;)LEsdlExample/AddressType;"); //All types currently used for ESDL mapping have string constructors
  1724. StringAttr s(text, size);
  1725. jstring strvalue = JNIenv->NewStringUTF(s);
  1726. jobject value = JNIenv->CallStaticObjectMethod(enumClass, fromString, strvalue);
  1727. JNIenv->DeleteLocalRef(strvalue);
  1728. checkException();
  1729. JNIenv->SetObjectField(getCurJavaObject(), fieldId, value);
  1730. JNIenv->DeleteLocalRef(value);
  1731. checkException();
  1732. }
  1733. virtual void outputString(unsigned size, const char *text, const char *fieldname)
  1734. {
  1735. DefStackEntry *parent = defStack.length() ? &defStack.tos() : NULL;
  1736. if (!parent)
  1737. return;
  1738. const char *defTypeName = NULL;
  1739. bool isArray = (parent->defObj && parent->defObj->getEsdlType()==EsdlTypeArray);
  1740. if (isArray)
  1741. defTypeName = parent->defObj->queryProp("type");
  1742. else
  1743. {
  1744. IEsdlDefStruct *defStruct = queryCurrentEsdlStruct();
  1745. if (!defStruct)
  1746. return;
  1747. IEsdlDefObject *defField = defStruct->queryChild(fieldname);
  1748. if (!defField)
  1749. return;
  1750. if (defField->getEsdlType()==EsdlTypeEnumRef)
  1751. return outputEnumString(size, text, fieldname, defField);
  1752. defTypeName = defField->queryProp("type");
  1753. }
  1754. if (!defTypeName)
  1755. return;
  1756. const char *javaSig = esdl2JavaSig(*esdl, defTypeName);
  1757. if (!javaSig)
  1758. return;
  1759. const char *fieldClassName = esdl2JavaFullClassName(*esdl, defTypeName);
  1760. jclass typeClass = FindClass(fieldClassName);
  1761. jmethodID typeStringConstructor = JNIenv->GetMethodID(typeClass, "<init>", "(Ljava/lang/String;)V"); //All types currently used for ESDL mapping have string constructors
  1762. StringAttr s(text, size);
  1763. jstring strvalue = JNIenv->NewStringUTF(s);
  1764. jobject value = JNIenv->NewObject(typeClass, typeStringConstructor, strvalue);
  1765. JNIenv->DeleteLocalRef(strvalue);
  1766. checkException();
  1767. if (!value)
  1768. return;
  1769. if (isArray)
  1770. JNIenv->CallObjectMethod(parent->obj, parent->append, value);
  1771. else
  1772. {
  1773. jfieldID fieldId = JNIenv->GetFieldID(getCurJavaClass(), fieldname, javaSig);
  1774. if (fieldId)
  1775. JNIenv->SetObjectField(getCurJavaObject(), fieldId, value);
  1776. }
  1777. JNIenv->DeleteLocalRef(value);
  1778. checkException();
  1779. }
  1780. void outputString(const char *text, const char *fieldname)
  1781. {
  1782. outputString((unsigned)strlen(text), text, fieldname);
  1783. }
  1784. virtual void outputNumericString(const char *field, const char *fieldname)
  1785. {
  1786. outputString(field, fieldname);
  1787. }
  1788. virtual void outputBool(bool value, const char *fieldname)
  1789. {
  1790. outputString(value ? "true" : "false", fieldname);
  1791. }
  1792. virtual void outputUInt(unsigned __int64 field, unsigned size, const char *fieldname)
  1793. {
  1794. StringBuffer value;
  1795. value.append(field);
  1796. outputString(value.length(), value, fieldname);
  1797. }
  1798. virtual void outputInt(__int64 field, unsigned size, const char *fieldname)
  1799. {
  1800. StringBuffer value;
  1801. value.append(field);
  1802. outputString(value.length(), value, fieldname);
  1803. }
  1804. virtual void outputReal(double field, const char *fieldname)
  1805. {
  1806. StringBuffer value;
  1807. value.append(field);
  1808. outputString(value.length(), value, fieldname);
  1809. }
  1810. virtual void outputDecimal(const void *field, unsigned size, unsigned precision, const char *fieldname)
  1811. {
  1812. Decimal d;
  1813. d.setDecimal(size, precision, field);
  1814. outputString(d.getCString(), fieldname);
  1815. }
  1816. virtual void outputUDecimal(const void *field, unsigned size, unsigned precision, const char *fieldname)
  1817. {
  1818. Decimal d;
  1819. d.setUDecimal(size, precision, field);
  1820. outputString(d.getCString(), fieldname);
  1821. }
  1822. virtual void outputQString(unsigned len, const char *field, const char *fieldname)
  1823. {
  1824. MemoryAttr tempBuffer;
  1825. char * temp;
  1826. if (len <= 100)
  1827. temp = (char *)alloca(len);
  1828. else
  1829. temp = (char *)tempBuffer.allocate(len);
  1830. rtlQStrToStr(len, temp, len, field);
  1831. outputString(len, temp, fieldname);
  1832. }
  1833. virtual void outputUnicode(unsigned len, const UChar *field, const char *fieldname)
  1834. {
  1835. char * buff = 0;
  1836. unsigned bufflen = 0;
  1837. rtlUnicodeToCodepageX(bufflen, buff, len, field, "utf-8");
  1838. outputString(bufflen, buff, fieldname);
  1839. rtlFree(buff);
  1840. }
  1841. virtual void outputUtf8(unsigned len, const char *field, const char *fieldname)
  1842. {
  1843. outputString(len, field, fieldname);
  1844. }
  1845. virtual void outputData(unsigned len, const void *value, const char *fieldname)
  1846. {
  1847. }
  1848. virtual void outputQuoted(const char *text) //would have to let beginNested represent simple types with content set using this?
  1849. {
  1850. }
  1851. virtual void outputBeginDataset(const char *dsname, bool nestChildren) //not used by ESDL engine
  1852. {
  1853. }
  1854. virtual void outputEndDataset(const char *dsname)
  1855. {
  1856. }
  1857. inline IEsdlDefObject *queryChildStructDefObj(IEsdlDefObject *child)
  1858. {
  1859. if (child)
  1860. {
  1861. switch (child->getEsdlType())
  1862. {
  1863. case EsdlTypeArray:
  1864. {
  1865. const char *structType = child->queryProp("type");
  1866. if (structType)
  1867. return esdl->queryObj(structType);
  1868. break;
  1869. }
  1870. case EsdlTypeElement:
  1871. {
  1872. const char *structType = child->queryProp("complex_type");
  1873. if (structType)
  1874. return esdl->queryObj(structType);
  1875. break;
  1876. }
  1877. default:
  1878. break;
  1879. }
  1880. }
  1881. return NULL;
  1882. }
  1883. virtual void outputBeginNested(const char *fieldname, bool nestChildren)
  1884. {
  1885. IEsdlDefStruct *defStruct = NULL;
  1886. IEsdlDefObject *defField = NULL;
  1887. IEsdlDefObject *defType = NULL;
  1888. if (!defStack.length())
  1889. {
  1890. defType = esdl->queryObj(fieldname);
  1891. }
  1892. else
  1893. {
  1894. DefStackEntry &parent = defStack.tos();
  1895. if (parent.defObj && parent.defObj->getEsdlType()==EsdlTypeArray)
  1896. {
  1897. defType = parent.defType;
  1898. }
  1899. else
  1900. {
  1901. defStruct = queryCurrentEsdlStruct();
  1902. if (defStruct)
  1903. {
  1904. defField = defStruct->queryChild(fieldname);
  1905. if (defField)
  1906. defType = queryChildStructDefObj(defField);
  1907. }
  1908. }
  1909. }
  1910. pushDefStackEntry(JNIenv, javaPackage, fieldname, defType, defField);
  1911. }
  1912. virtual void outputEndNested(const char *fieldname)
  1913. {
  1914. if (defStack.length()<=1) //don't destroy root object yet
  1915. return;
  1916. if (!streq(fieldname, defStack.tos().name)) //should be exception? or forgive and forget?
  1917. return;
  1918. popDefStackEntry(JNIenv);
  1919. }
  1920. virtual void outputSetAll()
  1921. {
  1922. }
  1923. virtual void outputBeginArray(const char *fieldname)
  1924. {
  1925. }
  1926. virtual void outputEndArray(const char *fieldname)
  1927. {
  1928. }
  1929. virtual void outputInlineXml(const char *text)
  1930. {
  1931. }
  1932. virtual void outputXmlns(const char *name, const char *uri)
  1933. {
  1934. }
  1935. virtual void cutFrom(IInterface *location, StringBuffer& databuf)
  1936. {
  1937. }
  1938. virtual void outputInline(const char* text)
  1939. {
  1940. }
  1941. public:
  1942. JNIEnv *JNIenv;
  1943. Linked<IEsdlDefinition> esdl;
  1944. StringAttr javaPackage;
  1945. StringAttr esdlType;
  1946. class DefStackEntry : public CInterface
  1947. {
  1948. public:
  1949. DefStackEntry(const char *fieldname, IEsdlDefObject *_defType, IEsdlDefObject *_defObj) : name(fieldname), defType(_defType), defObj(_defObj), Class(0), obj(0), constructor(0), append(0), fieldId(0)
  1950. {
  1951. }
  1952. ~DefStackEntry()
  1953. {
  1954. }
  1955. public:
  1956. Linked<IEsdlDefObject> defType;
  1957. Linked<IEsdlDefObject> defObj;
  1958. StringAttr name;
  1959. jclass Class;
  1960. jmethodID constructor;
  1961. jmethodID append;
  1962. jfieldID fieldId;
  1963. jobject obj;
  1964. };
  1965. jobject MakeObjectGlobal(jobject local)
  1966. {
  1967. if (!local)
  1968. return 0;
  1969. jobject global = JNIenv->NewGlobalRef(local);
  1970. JNIenv->DeleteLocalRef(local);
  1971. return global;
  1972. }
  1973. jclass FindClass(const char *name)
  1974. {
  1975. jclass *pClass = javaClasses.getValue(name);
  1976. if (pClass)
  1977. return *pClass;
  1978. jclass Class = (jclass) MakeObjectGlobal(JNIenv->FindClass(name));
  1979. javaClasses.setValue(name, Class); //even save if result has no class
  1980. return Class;
  1981. }
  1982. void popDefStackEntry(JNIEnv *JNIenv)
  1983. {
  1984. if (!defStack.length())
  1985. return;
  1986. Owned<DefStackEntry> entry = &defStack.popGet();
  1987. if (entry->obj)
  1988. JNIenv->DeleteGlobalRef(entry->obj);
  1989. }
  1990. void pushDefStackEntry(JNIEnv *JNIenv, const char *package, const char *fieldname, IEsdlDefObject *defType, IEsdlDefObject *defObject)
  1991. {
  1992. DefStackEntry *parent = defStack.length() ? &defStack.tos() : NULL;
  1993. Owned<DefStackEntry> entry = new DefStackEntry(fieldname, defType, defObject);
  1994. JNIenv->ExceptionClear();
  1995. if (defObject && defObject->getEsdlType()==EsdlTypeArray)
  1996. {
  1997. const char *javaClassName = "java/util/ArrayList";
  1998. entry->Class = FindClass(javaClassName);
  1999. if (entry->Class)
  2000. {
  2001. entry->constructor = JNIenv->GetMethodID(entry->Class, "<init>", "()V");
  2002. entry->append = JNIenv->GetMethodID(entry->Class, "add", "(Ljava/lang/Object;)Z");
  2003. entry->obj = MakeObjectGlobal(JNIenv->NewObject(entry->Class, entry->constructor));
  2004. javaembed::checkException(JNIenv, false);
  2005. if (entry->obj)
  2006. {
  2007. if (parent && parent->Class)
  2008. {
  2009. VStringBuffer javaSig("L%s;", javaClassName);
  2010. entry->fieldId = JNIenv->GetFieldID(parent->Class, fieldname, javaSig);
  2011. if (parent->obj && entry->fieldId)
  2012. JNIenv->SetObjectField(parent->obj, entry->fieldId, entry->obj);
  2013. }
  2014. }
  2015. }
  2016. }
  2017. else if (defType)
  2018. {
  2019. VStringBuffer javaClassName("%s/%s", package, defType->queryName());
  2020. entry->Class = FindClass(javaClassName);
  2021. if (entry->Class)
  2022. {
  2023. entry->constructor = JNIenv->GetMethodID(entry->Class, "<init>", "()V");
  2024. entry->obj = MakeObjectGlobal(JNIenv->NewObject(entry->Class, entry->constructor));
  2025. javaembed::checkException(JNIenv, false);
  2026. if (entry->obj)
  2027. {
  2028. if (parent)
  2029. {
  2030. if (parent->defObj && parent->defObj->getEsdlType()==EsdlTypeArray)
  2031. JNIenv->CallObjectMethod(parent->obj, parent->append, entry->obj);
  2032. else if (parent->Class)
  2033. {
  2034. VStringBuffer javaSig("L%s;", javaClassName.str());
  2035. entry->fieldId = JNIenv->GetFieldID(parent->Class, fieldname, javaSig);
  2036. if (parent->obj && entry->fieldId)
  2037. JNIenv->SetObjectField(parent->obj, entry->fieldId, entry->obj);
  2038. }
  2039. javaembed::checkException(JNIenv, false);
  2040. }
  2041. }
  2042. }
  2043. }
  2044. defStack.append(*entry.getClear());
  2045. }
  2046. CIArrayOf<DefStackEntry> defStack;
  2047. MapStringTo<jclass> javaClasses;
  2048. };
  2049. // Each call to a Java function will use a new JavaEmbedScriptContext object
  2050. #define MAX_JNI_ARGS 10
  2051. class JavaClassReader
  2052. {
  2053. public:
  2054. JavaClassReader(const char *filename)
  2055. {
  2056. // Pull apart a class file to see its name and signature.
  2057. /* From https://docs.oracle.com/javase/specs/jvms/se7/html/jvms-4.html#jvms-4.1
  2058. ClassFile {
  2059. u4 magic;
  2060. u2 minor_version;
  2061. u2 major_version;
  2062. u2 constant_pool_count;
  2063. cp_info constant_pool[constant_pool_count-1];
  2064. u2 access_flags;
  2065. u2 this_class;
  2066. u2 super_class;
  2067. u2 interfaces_count;
  2068. u2 interfaces[interfaces_count];
  2069. u2 fields_count;
  2070. field_info fields[fields_count];
  2071. u2 methods_count;
  2072. method_info methods[methods_count];
  2073. u2 attributes_count;
  2074. attribute_info attributes[attributes_count];
  2075. }
  2076. */
  2077. #ifdef TRACE_CLASSFILE
  2078. DBGLOG("Reading class file created in %s", filename);
  2079. #endif
  2080. Owned<IFile> file = createIFile(filename);
  2081. OwnedIFileIO io = file->open(IFOread);
  2082. assertex(io);
  2083. read(io, 0, (size32_t)-1, b);
  2084. b.setEndian(__BIG_ENDIAN);
  2085. uint32_t magic;
  2086. b.read(magic);
  2087. if (magic != 0xcafebabe)
  2088. throwUnexpected();
  2089. uint16_t major, minor, cpc;
  2090. b.read(major);
  2091. b.read(minor);
  2092. b.read(cpc);
  2093. constOffsets = new unsigned[cpc];
  2094. constOffsets[0] = 0;
  2095. for (int i = 0; i < cpc-1; i++) // There are only cpc-1 entries, for reasons best known to the java designers
  2096. {
  2097. constOffsets[i+1] = b.getPos();
  2098. byte tag;
  2099. b.read(tag);
  2100. switch (tag)
  2101. {
  2102. case CONSTANT_Class:
  2103. uint16_t idx;
  2104. b.read(idx);
  2105. #ifdef TRACE_CLASSFILE
  2106. DBGLOG("%u: Class %u", i+1, idx);
  2107. #endif
  2108. break;
  2109. case CONSTANT_Fieldref:
  2110. case CONSTANT_Methodref:
  2111. case CONSTANT_InterfaceMethodref:
  2112. uint16_t classIdx;
  2113. uint16_t nametypeIdx;
  2114. b.read(classIdx);
  2115. b.read(nametypeIdx);
  2116. #ifdef TRACE_CLASSFILE
  2117. DBGLOG("%u: ref(%u) class %u nametype %u", i+1, tag, classIdx, nametypeIdx);
  2118. #endif
  2119. break;
  2120. case CONSTANT_String:
  2121. #ifdef TRACE_CLASSFILE
  2122. DBGLOG("%u: Tag %u", i+1, tag);
  2123. #endif
  2124. b.skip(2);
  2125. break;
  2126. case CONSTANT_Integer:
  2127. case CONSTANT_Float:
  2128. #ifdef TRACE_CLASSFILE
  2129. DBGLOG("%u: Tag %u", i+1, tag);
  2130. #endif
  2131. b.skip(4);
  2132. break;
  2133. case CONSTANT_Long:
  2134. case CONSTANT_Double:
  2135. #ifdef TRACE_CLASSFILE
  2136. DBGLOG("%u: Tag %u", i+1, tag);
  2137. #endif
  2138. b.skip(8);
  2139. break;
  2140. case CONSTANT_NameAndType:
  2141. uint16_t nameIdx;
  2142. uint16_t descIdx;
  2143. b.read(nameIdx);
  2144. b.read(descIdx);
  2145. #ifdef TRACE_CLASSFILE
  2146. DBGLOG("%u: NameAndType(%u) name %u desc %u", i+1, tag, nameIdx, descIdx);
  2147. #endif
  2148. break;
  2149. case CONSTANT_Utf8:
  2150. // length-prefixed
  2151. uint16_t length;
  2152. b.read(length);
  2153. const byte *val;
  2154. val = b.readDirect(length);
  2155. #ifdef TRACE_CLASSFILE
  2156. DBGLOG("%u: %.*s", i+1, length, val);
  2157. #endif
  2158. break;
  2159. case CONSTANT_MethodHandle:
  2160. #ifdef TRACE_CLASSFILE
  2161. DBGLOG("%u: Tag %u", i+1, tag);
  2162. #endif
  2163. b.skip(3);
  2164. break;
  2165. case CONSTANT_MethodType:
  2166. #ifdef TRACE_CLASSFILE
  2167. DBGLOG("%u: Tag %u", i+1, tag);
  2168. #endif
  2169. b.skip(2);
  2170. break;
  2171. case CONSTANT_InvokeDynamic:
  2172. #ifdef TRACE_CLASSFILE
  2173. DBGLOG("%u: Tag %u", i+1, tag);
  2174. #endif
  2175. b.skip(4);
  2176. break;
  2177. default:
  2178. DBGLOG("Unexpected tag %u reading bytecode file", tag);
  2179. throwUnexpected();
  2180. }
  2181. }
  2182. uint16_t access_flags; b.read(access_flags);
  2183. uint16_t this_class; b.read(this_class);
  2184. uint16_t super_class; b.read(super_class);
  2185. uint16_t interfaces_count; b.read(interfaces_count);
  2186. b.skip(interfaces_count*sizeof(uint16_t));
  2187. uint16_t fields_count; b.read(fields_count);
  2188. #ifdef TRACE_CLASSFILE
  2189. DBGLOG("Access flags %x this_class=%u super_class=%u interfaces_count=%u fields_count=%u", access_flags, this_class, super_class, interfaces_count, fields_count);
  2190. #endif
  2191. for (unsigned i = 0; i < fields_count; i++)
  2192. {
  2193. b.skip(6);
  2194. uint16_t attr_count;
  2195. b.read(attr_count);
  2196. for (unsigned j = 0; j < attr_count; j++)
  2197. {
  2198. b.skip(2);
  2199. uint32_t attr_length;
  2200. b.read(attr_length);
  2201. b.skip(attr_length);
  2202. }
  2203. }
  2204. uint16_t methods_count; b.read(methods_count);
  2205. #ifdef TRACE_CLASSFILE
  2206. DBGLOG("methods_count %u", methods_count);
  2207. #endif
  2208. for (unsigned i = 0; i < methods_count; i++)
  2209. {
  2210. uint16_t flags; b.read(flags);
  2211. uint16_t name; b.read(name);
  2212. uint16_t desc; b.read(desc);
  2213. #ifdef TRACE_CLASSFILE
  2214. DBGLOG("Method %u name %u desc %u flags %x", i, name, desc, flags);
  2215. #endif
  2216. if (flags & ACC_PUBLIC)
  2217. {
  2218. StringAttr thisName;
  2219. readUtf(thisName, name);
  2220. StringAttr thisSig;
  2221. readUtf(thisSig, desc);
  2222. methodNames.append(thisName);
  2223. methodSigs.append(thisSig);
  2224. methodFlags.append(flags);
  2225. }
  2226. uint16_t attr_count;
  2227. b.read(attr_count);
  2228. for (unsigned j = 0; j < attr_count; j++)
  2229. {
  2230. b.skip(2);
  2231. uint32_t attr_length;
  2232. b.read(attr_length);
  2233. b.skip(attr_length);
  2234. }
  2235. }
  2236. /* Don't bother reading attributes as they are not really interesting to us
  2237. uint16_t attributes_count; b.read(attributes_count);
  2238. #ifdef TRACE_CLASSFILE
  2239. DBGLOG("attributes_count %u", attributes_count);
  2240. #endif
  2241. for (unsigned i = 0; i < attributes_count; i++)
  2242. {
  2243. b.skip(2);
  2244. uint32_t attr_length;
  2245. b.read(attr_length);
  2246. b.skip(attr_length);
  2247. }
  2248. #ifdef TRACE_CLASSFILE
  2249. DBGLOG("%u of %u bytes remaining", b.remaining(), b.length());
  2250. #endif
  2251. */
  2252. // Now we can find this class name
  2253. readTag(this_class, CONSTANT_Class);
  2254. readUtf(className, readIdx());
  2255. }
  2256. ~JavaClassReader()
  2257. {
  2258. delete [] constOffsets;
  2259. }
  2260. StringBuffer & getSignature(StringBuffer &ret, unsigned idx)
  2261. {
  2262. if (!methodNames.isItem(idx))
  2263. throw makeStringException(0, "No public static method found");
  2264. ret.appendf("%s.%s:", className.get(), methodNames.item(idx));
  2265. if ((methodFlags[idx] & ACC_STATIC) == 0)
  2266. ret.append('@');
  2267. return ret.append(methodSigs.item(idx));
  2268. }
  2269. MemoryBuffer &getEmbedData(MemoryBuffer &result, const char *funcName, bool mainClass)
  2270. {
  2271. result.setEndian(__BIG_ENDIAN);
  2272. StringBuffer signature;
  2273. if (mainClass)
  2274. {
  2275. unsigned methodIdx = getFunctionIdx(funcName);
  2276. getSignature(signature, methodIdx);
  2277. }
  2278. else
  2279. signature.set(className);
  2280. result.append((size32_t) signature.length());
  2281. result.append(signature.length(), signature.str());
  2282. result.append((size32_t) b.length());
  2283. result.append(b);
  2284. return result;
  2285. }
  2286. enum access_flag : uint16_t
  2287. {
  2288. ACC_PUBLIC = 0x0001, // Declared public; may be accessed from outside its package.
  2289. ACC_PRIVATE = 0x0002, // Declared private; accessible only within the defining class.
  2290. ACC_PROTECTED = 0x0004, // Declared protected; may be accessed within subclasses.
  2291. ACC_STATIC = 0x0008, // Declared static.
  2292. ACC_FINAL = 0x0010, // Declared final; must not be overridden (§5.4.5).
  2293. ACC_SYNCHRONIZED = 0x0020, // Declared synchronized; invocation is wrapped by a monitor use.
  2294. ACC_BRIDGE = 0x0040, // A bridge method, generated by the compiler.
  2295. ACC_VARARGS = 0x0080, // Declared with variable number of arguments.
  2296. ACC_NATIVE = 0x0100, // Declared native; implemented in a language other than Java.
  2297. ACC_ABSTRACT = 0x0400, // Declared abstract; no implementation is provided.
  2298. ACC_STRICT = 0x0800, // Declared strictfp; floating-point mode is FP-strict.
  2299. ACC_SYNTHETIC = 0x1000, // Declared synthetic; not present in the source code.
  2300. };
  2301. unsigned getFlags(const char *funcName)
  2302. {
  2303. unsigned idx = getFunctionIdx(funcName);
  2304. return methodFlags[idx];
  2305. }
  2306. private:
  2307. unsigned getFunctionIdx(const char *funcName)
  2308. {
  2309. unsigned methodIdx = (unsigned) -1;
  2310. ForEachItemIn(idx, methodNames)
  2311. {
  2312. if (streq(funcName, methodNames[idx]))
  2313. {
  2314. if (methodIdx != (unsigned) -1)
  2315. throw makeStringExceptionV(0, "Embedded java has multiple public methods called %s", funcName);
  2316. methodIdx = idx;
  2317. }
  2318. }
  2319. if (methodIdx == (unsigned) -1)
  2320. throw makeStringExceptionV(0, "Embedded java should export a public method %s", funcName);
  2321. return methodIdx;
  2322. }
  2323. uint16_t readIdx()
  2324. {
  2325. uint16_t idx;
  2326. b.read(idx);
  2327. return idx;
  2328. }
  2329. void readTag(unsigned idx, byte expected)
  2330. {
  2331. b.reset(constOffsets[idx]);
  2332. byte tag;
  2333. b.read(tag);
  2334. assertex(tag == expected);
  2335. }
  2336. void readUtf(StringAttr &dest, unsigned idx)
  2337. {
  2338. auto savepos = b.getPos();
  2339. readTag(idx, CONSTANT_Utf8);
  2340. uint16_t length;
  2341. b.read(length);
  2342. dest.set((const char *) b.readDirect(length), length);
  2343. b.reset(savepos);
  2344. }
  2345. enum const_type
  2346. {
  2347. CONSTANT_Class = 7,
  2348. CONSTANT_Fieldref = 9,
  2349. CONSTANT_Methodref = 10,
  2350. CONSTANT_InterfaceMethodref = 11,
  2351. CONSTANT_String = 8,
  2352. CONSTANT_Integer = 3,
  2353. CONSTANT_Float = 4,
  2354. CONSTANT_Long = 5,
  2355. CONSTANT_Double = 6,
  2356. CONSTANT_NameAndType = 12,
  2357. CONSTANT_Utf8 = 1,
  2358. CONSTANT_MethodHandle = 15,
  2359. CONSTANT_MethodType = 16,
  2360. CONSTANT_InvokeDynamic = 18
  2361. };
  2362. MemoryBuffer b;
  2363. unsigned *constOffsets = nullptr;
  2364. StringAttr className;
  2365. StringArray methodNames;
  2366. StringArray methodSigs;
  2367. UnsignedArray methodFlags;
  2368. };
  2369. class JavaEmbedImportContext : public CInterfaceOf<IEmbedFunctionContext>
  2370. {
  2371. public:
  2372. JavaEmbedImportContext(ICodeContext *codeCtx, JavaThreadContext *_sharedCtx, jobject _instance, unsigned flags, const char *options)
  2373. : sharedCtx(_sharedCtx), JNIenv(sharedCtx->JNIenv), instance(_instance)
  2374. {
  2375. if (instance)
  2376. instance = JNIenv->NewGlobalRef(instance);
  2377. if (flags & EFthreadlocal)
  2378. sharedCtx->registerContext(this);
  2379. argcount = 0;
  2380. argsig = NULL;
  2381. nonStatic = (instance != nullptr);
  2382. javaClass = nullptr;
  2383. StringArray opts;
  2384. opts.appendList(options, ",");
  2385. ForEachItemIn(idx, opts)
  2386. {
  2387. const char *opt = opts.item(idx);
  2388. const char *val = strchr(opt, '=');
  2389. if (val)
  2390. {
  2391. StringBuffer optName(val-opt, opt);
  2392. val++;
  2393. if (stricmp(optName, "classpath")==0)
  2394. classpath.set(val);
  2395. else if (strieq(optName, "persist"))
  2396. {
  2397. if (persistMode != persistNone)
  2398. throw MakeStringException(MSGAUD_user, 0, "javaembed: Persist option specified more than once");
  2399. persistMode = getPersistMode(val);
  2400. switch (persistMode)
  2401. {
  2402. case persistWorkunit:
  2403. case persistQuery:
  2404. engine = codeCtx->queryEngineContext();
  2405. if (!engine)
  2406. throw MakeStringException(MSGAUD_user, 0, "javaembed: Persist mode '%s' not supported here", val);
  2407. break;
  2408. }
  2409. }
  2410. else
  2411. throw MakeStringException(0, "javaembed: Unknown option %s", optName.str());
  2412. }
  2413. }
  2414. }
  2415. ~JavaEmbedImportContext()
  2416. {
  2417. if (javaClass)
  2418. JNIenv->DeleteGlobalRef(javaClass);
  2419. if (instance)
  2420. JNIenv->DeleteGlobalRef(instance);
  2421. if (classLoader)
  2422. JNIenv->DeleteGlobalRef(instance);
  2423. }
  2424. virtual bool getBooleanResult()
  2425. {
  2426. switch (*returnType)
  2427. {
  2428. case 'Z': return result.z;
  2429. case 'L':
  2430. {
  2431. // Result should be of class 'Boolean'
  2432. if (!result.l)
  2433. return false;
  2434. jmethodID getVal = JNIenv->GetMethodID(JNIenv->GetObjectClass(result.l), "booleanValue", "()Z");
  2435. if (!getVal)
  2436. throw MakeStringException(MSGAUD_user, 0, "javaembed: Type mismatch on result");
  2437. bool ret=JNIenv->CallBooleanMethod(result.l, getVal);
  2438. checkException();
  2439. return ret;
  2440. }
  2441. default:
  2442. throw MakeStringException(MSGAUD_user, 0, "javaembed: Type mismatch on result");
  2443. }
  2444. }
  2445. virtual void getDataResult(size32_t &__len, void * &__result)
  2446. {
  2447. if (strcmp(returnType, "[B")!=0)
  2448. throw MakeStringException(MSGAUD_user, 0, "javaembed: Type mismatch on result");
  2449. jbyteArray array = (jbyteArray) result.l;
  2450. __len = (array != NULL ? JNIenv->GetArrayLength(array) : 0);
  2451. __result = (__len > 0 ? rtlMalloc(__len) : NULL);
  2452. if (__result)
  2453. JNIenv->GetByteArrayRegion(array, 0, __len, (jbyte *) __result);
  2454. }
  2455. virtual double getRealResult()
  2456. {
  2457. switch (*returnType)
  2458. {
  2459. case 'D': return result.d;
  2460. case 'F': return result.f;
  2461. case 'L':
  2462. {
  2463. // Result should be of class 'Number'
  2464. if (!result.l)
  2465. return 0;
  2466. jmethodID getVal = JNIenv->GetMethodID(JNIenv->GetObjectClass(result.l), "doubleValue", "()D");
  2467. if (!getVal)
  2468. throw MakeStringException(MSGAUD_user, 0, "javaembed: Type mismatch on result");
  2469. double ret = JNIenv->CallDoubleMethod(result.l, getVal);
  2470. checkException();
  2471. return ret;
  2472. }
  2473. default:
  2474. throw MakeStringException(MSGAUD_user, 0, "javaembed: Type mismatch on result");
  2475. }
  2476. }
  2477. virtual __int64 getSignedResult()
  2478. {
  2479. switch (*returnType)
  2480. {
  2481. case 'B': return result.b;
  2482. case 'S': return result.s;
  2483. case 'I': return result.i;
  2484. case 'J': return result.j;
  2485. case 'L':
  2486. {
  2487. // Result should be of class 'Number'
  2488. if (!result.l)
  2489. return 0;
  2490. jmethodID getVal = JNIenv->GetMethodID(JNIenv->GetObjectClass(result.l), "longValue", "()J");
  2491. if (!getVal)
  2492. throw MakeStringException(MSGAUD_user, 0, "javaembed: Type mismatch on result");
  2493. __int64 ret = JNIenv->CallLongMethod(result.l, getVal);
  2494. checkException();
  2495. return ret;
  2496. }
  2497. default:
  2498. throw MakeStringException(MSGAUD_user, 0, "javaembed: Type mismatch on result");
  2499. }
  2500. }
  2501. virtual unsigned __int64 getUnsignedResult()
  2502. {
  2503. throw MakeStringException(MSGAUD_user, 0, "javaembed: Unsigned results not supported"); // Java doesn't support unsigned
  2504. }
  2505. virtual void getStringResult(size32_t &__len, char * &__result)
  2506. {
  2507. switch (*returnType)
  2508. {
  2509. case 'C': // Single char returned, prototyped as STRING or STRING1 in ECL
  2510. rtlUnicodeToStrX(__len, __result, 1, &result.c);
  2511. break;
  2512. case 'L':
  2513. {
  2514. jstring sresult = (jstring) result.l;
  2515. if (sresult)
  2516. {
  2517. size_t size = JNIenv->GetStringUTFLength(sresult); // in bytes
  2518. const char *text = JNIenv->GetStringUTFChars(sresult, NULL);
  2519. size32_t chars = rtlUtf8Length(size, text);
  2520. rtlUtf8ToStrX(__len, __result, chars, text);
  2521. JNIenv->ReleaseStringUTFChars(sresult, text);
  2522. }
  2523. else
  2524. {
  2525. __len = 0;
  2526. __result = NULL;
  2527. }
  2528. break;
  2529. }
  2530. default:
  2531. throw MakeStringException(MSGAUD_user, 0, "javaembed: Type mismatch on result");
  2532. }
  2533. }
  2534. virtual void getUTF8Result(size32_t &__chars, char * &__result)
  2535. {
  2536. switch (*returnType)
  2537. {
  2538. case 'C': // Single jchar returned, prototyped as UTF8 in ECL
  2539. rtlUnicodeToUtf8X(__chars, __result, 1, &result.c);
  2540. break;
  2541. case 'L':
  2542. {
  2543. jstring sresult = (jstring) result.l;
  2544. if (sresult)
  2545. {
  2546. size_t size = JNIenv->GetStringUTFLength(sresult); // Returns length in bytes (not chars)
  2547. const char * text = JNIenv->GetStringUTFChars(sresult, NULL);
  2548. rtlUtf8ToUtf8X(__chars, __result, rtlUtf8Length(size, text), text);
  2549. JNIenv->ReleaseStringUTFChars(sresult, text);
  2550. }
  2551. else
  2552. {
  2553. __chars = 0;
  2554. __result = NULL;
  2555. }
  2556. break;
  2557. }
  2558. default:
  2559. throw MakeStringException(MSGAUD_user, 0, "javaembed: Type mismatch on result");
  2560. }
  2561. }
  2562. virtual void getUnicodeResult(size32_t &__chars, UChar * &__result)
  2563. {
  2564. switch (*returnType)
  2565. {
  2566. case 'C': // Single jchar returned, prototyped as UNICODE or UNICODE1 in ECL
  2567. rtlUnicodeToUnicodeX(__chars, __result, 1, &result.c);
  2568. break;
  2569. case 'L':
  2570. {
  2571. jstring sresult = (jstring) result.l;
  2572. if (sresult)
  2573. {
  2574. size_t size = JNIenv->GetStringUTFLength(sresult); // in bytes
  2575. const char *text = JNIenv->GetStringUTFChars(sresult, NULL);
  2576. size32_t chars = rtlUtf8Length(size, text);
  2577. rtlUtf8ToUnicodeX(__chars, __result, chars, text);
  2578. JNIenv->ReleaseStringUTFChars(sresult, text);
  2579. }
  2580. else
  2581. {
  2582. __chars = 0;
  2583. __result = NULL;
  2584. }
  2585. break;
  2586. }
  2587. default:
  2588. throw MakeStringException(MSGAUD_user, 0, "javaembed: Type mismatch on result");
  2589. }
  2590. }
  2591. virtual void getSetResult(bool & __isAllResult, size32_t & __resultBytes, void * & __result, int _elemType, size32_t elemSize)
  2592. {
  2593. if (*returnType != '[')
  2594. throw MakeStringException(MSGAUD_user, 0, "javaembed: Type mismatch on result (array expected)");
  2595. type_t elemType = (type_t) _elemType;
  2596. jarray array = (jarray) result.l;
  2597. int numResults = (array != NULL ? JNIenv->GetArrayLength(array) : 0);
  2598. rtlRowBuilder out;
  2599. byte *outData = NULL;
  2600. size32_t outBytes = 0;
  2601. if (numResults > 0)
  2602. {
  2603. if (elemSize != UNKNOWN_LENGTH)
  2604. {
  2605. out.ensureAvailable(numResults * elemSize); // MORE - check for overflow?
  2606. outData = out.getbytes();
  2607. }
  2608. switch(returnType[1])
  2609. {
  2610. case 'Z':
  2611. checkType(type_boolean, sizeof(jboolean), elemType, elemSize);
  2612. JNIenv->GetBooleanArrayRegion((jbooleanArray) array, 0, numResults, (jboolean *) outData);
  2613. break;
  2614. case 'B':
  2615. checkType(type_int, sizeof(jbyte), elemType, elemSize);
  2616. JNIenv->GetByteArrayRegion((jbyteArray) array, 0, numResults, (jbyte *) outData);
  2617. break;
  2618. case 'C':
  2619. // we COULD map to a set of string1, but is there any point?
  2620. throw MakeStringException(0, "javaembed: Return type mismatch (char[] not supported)");
  2621. break;
  2622. case 'S':
  2623. checkType(type_int, sizeof(jshort), elemType, elemSize);
  2624. JNIenv->GetShortArrayRegion((jshortArray) array, 0, numResults, (jshort *) outData);
  2625. break;
  2626. case 'I':
  2627. checkType(type_int, sizeof(jint), elemType, elemSize);
  2628. JNIenv->GetIntArrayRegion((jintArray) array, 0, numResults, (jint *) outData);
  2629. break;
  2630. case 'J':
  2631. checkType(type_int, sizeof(jlong), elemType, elemSize);
  2632. JNIenv->GetLongArrayRegion((jlongArray) array, 0, numResults, (jlong *) outData);
  2633. break;
  2634. case 'F':
  2635. checkType(type_real, sizeof(jfloat), elemType, elemSize);
  2636. JNIenv->GetFloatArrayRegion((jfloatArray) array, 0, numResults, (jfloat *) outData);
  2637. break;
  2638. case 'D':
  2639. checkType(type_real, sizeof(jdouble), elemType, elemSize);
  2640. JNIenv->GetDoubleArrayRegion((jdoubleArray) array, 0, numResults, (jdouble *) outData);
  2641. break;
  2642. case 'L':
  2643. if (strcmp(returnType, "[Ljava/lang/String;") == 0)
  2644. {
  2645. for (int i = 0; i < numResults; i++)
  2646. {
  2647. jstring elem = (jstring) JNIenv->GetObjectArrayElement((jobjectArray) array, i);
  2648. size_t lenBytes = JNIenv->GetStringUTFLength(elem); // in bytes
  2649. const char *text = JNIenv->GetStringUTFChars(elem, NULL);
  2650. switch (elemType)
  2651. {
  2652. case type_string:
  2653. if (elemSize == UNKNOWN_LENGTH)
  2654. {
  2655. out.ensureAvailable(outBytes + lenBytes + sizeof(size32_t));
  2656. outData = out.getbytes() + outBytes;
  2657. * (size32_t *) outData = lenBytes;
  2658. rtlStrToStr(lenBytes, outData+sizeof(size32_t), lenBytes, text);
  2659. outBytes += lenBytes + sizeof(size32_t);
  2660. }
  2661. else
  2662. rtlStrToStr(elemSize, outData, lenBytes, text);
  2663. break;
  2664. case type_varstring:
  2665. if (elemSize == UNKNOWN_LENGTH)
  2666. {
  2667. out.ensureAvailable(outBytes + lenBytes + 1);
  2668. outData = out.getbytes() + outBytes;
  2669. rtlStrToVStr(0, outData, lenBytes, text);
  2670. outBytes += lenBytes + 1;
  2671. }
  2672. else
  2673. rtlStrToVStr(elemSize, outData, lenBytes, text); // Fixed size null terminated strings... weird.
  2674. break;
  2675. case type_utf8:
  2676. case type_unicode:
  2677. {
  2678. size32_t numchars = rtlUtf8Length(lenBytes, text);
  2679. if (elemType == type_utf8)
  2680. {
  2681. assertex (elemSize == UNKNOWN_LENGTH);
  2682. out.ensureAvailable(outBytes + lenBytes + sizeof(size32_t));
  2683. outData = out.getbytes() + outBytes;
  2684. * (size32_t *) outData = numchars;
  2685. rtlStrToStr(lenBytes, outData+sizeof(size32_t), lenBytes, text);
  2686. outBytes += lenBytes + sizeof(size32_t);
  2687. }
  2688. else
  2689. {
  2690. if (elemSize == UNKNOWN_LENGTH)
  2691. {
  2692. // You can't assume that number of chars in utf8 matches number in unicode16 ...
  2693. size32_t numchars16;
  2694. rtlDataAttr unicode16;
  2695. rtlUtf8ToUnicodeX(numchars16, unicode16.refustr(), numchars, text);
  2696. out.ensureAvailable(outBytes + numchars16*sizeof(UChar) + sizeof(size32_t));
  2697. outData = out.getbytes() + outBytes;
  2698. * (size32_t *) outData = numchars16;
  2699. rtlUnicodeToUnicode(numchars16, (UChar *) (outData+sizeof(size32_t)), numchars16, unicode16.getustr());
  2700. outBytes += numchars16*sizeof(UChar) + sizeof(size32_t);
  2701. }
  2702. else
  2703. rtlUtf8ToUnicode(elemSize / sizeof(UChar), (UChar *) outData, numchars, text);
  2704. }
  2705. break;
  2706. }
  2707. default:
  2708. JNIenv->ReleaseStringUTFChars(elem, text);
  2709. throw MakeStringException(0, "javaembed: Return type mismatch (ECL string type expected)");
  2710. }
  2711. JNIenv->ReleaseStringUTFChars(elem, text);
  2712. JNIenv->DeleteLocalRef(elem);
  2713. if (elemSize != UNKNOWN_LENGTH)
  2714. outData += elemSize;
  2715. }
  2716. }
  2717. else
  2718. throw MakeStringException(0, "javaembed: Return type mismatch (%s[] not supported)", returnType+2);
  2719. break;
  2720. }
  2721. }
  2722. __isAllResult = false;
  2723. __resultBytes = elemSize == UNKNOWN_LENGTH ? outBytes : elemSize * numResults;
  2724. __result = out.detachdata();
  2725. }
  2726. virtual IRowStream *getDatasetResult(IEngineRowAllocator * _resultAllocator)
  2727. {
  2728. return new JavaRowStream(result.l, _resultAllocator);
  2729. }
  2730. virtual byte * getRowResult(IEngineRowAllocator * _resultAllocator)
  2731. {
  2732. RtlDynamicRowBuilder rowBuilder(_resultAllocator);
  2733. size32_t len = getRowResult(result.l, rowBuilder);
  2734. return (byte *) rowBuilder.finalizeRowClear(len);
  2735. }
  2736. virtual size32_t getTransformResult(ARowBuilder & builder)
  2737. {
  2738. return getRowResult(result.l, builder);
  2739. }
  2740. virtual void bindBooleanParam(const char *name, bool val)
  2741. {
  2742. if (*argsig != 'Z')
  2743. typeError("BOOLEAN");
  2744. argsig++;
  2745. jvalue v;
  2746. v.z = val;
  2747. addArg(v);
  2748. }
  2749. virtual void bindDataParam(const char *name, size32_t len, const void *val)
  2750. {
  2751. if (argsig[0] != '[' || argsig[1] != 'B')
  2752. typeError("DATA");
  2753. argsig += 2;
  2754. jvalue v;
  2755. jbyteArray javaData = JNIenv->NewByteArray(len);
  2756. JNIenv->SetByteArrayRegion(javaData, 0, len, (jbyte *) val);
  2757. v.l = javaData;
  2758. addArg(v);
  2759. }
  2760. virtual void bindFloatParam(const char *name, float val)
  2761. {
  2762. // Could argue that the size should match...
  2763. jvalue v;
  2764. switch(*argsig)
  2765. {
  2766. case 'D':
  2767. v.d = val;
  2768. break;
  2769. case 'F':
  2770. v.f = val;
  2771. break;
  2772. default:
  2773. typeError("REAL");
  2774. break;
  2775. }
  2776. argsig++;
  2777. addArg(v);
  2778. }
  2779. virtual void bindRealParam(const char *name, double val)
  2780. {
  2781. jvalue v;
  2782. switch(*argsig)
  2783. {
  2784. case 'D':
  2785. v.d = val;
  2786. break;
  2787. case 'F':
  2788. v.f = val;
  2789. break;
  2790. default:
  2791. typeError("REAL");
  2792. break;
  2793. }
  2794. argsig++;
  2795. addArg(v);
  2796. }
  2797. virtual void bindSignedSizeParam(const char *name, int size, __int64 val)
  2798. {
  2799. bindSignedParam(name, val);
  2800. }
  2801. virtual void bindSignedParam(const char *name, __int64 val)
  2802. {
  2803. jvalue v;
  2804. switch(*argsig)
  2805. {
  2806. case 'I':
  2807. v.i = val;
  2808. break;
  2809. case 'J':
  2810. v.j = val;
  2811. break;
  2812. case 'S':
  2813. v.s = val;
  2814. break;
  2815. case 'B':
  2816. v.b = val;
  2817. break;
  2818. default:
  2819. typeError("INTEGER");
  2820. break;
  2821. }
  2822. argsig++;
  2823. addArg(v);
  2824. }
  2825. virtual void bindUnsignedSizeParam(const char *name, int size, unsigned __int64 val)
  2826. {
  2827. bindUnsignedParam(name, val);
  2828. }
  2829. virtual void bindUnsignedParam(const char *name, unsigned __int64 val)
  2830. {
  2831. throw MakeStringException(MSGAUD_user, 0, "javaembed: Unsigned parameters not supported"); // Java doesn't support unsigned
  2832. }
  2833. virtual void bindStringParam(const char *name, size32_t len, const char *val)
  2834. {
  2835. jvalue v;
  2836. switch(*argsig)
  2837. {
  2838. case 'C':
  2839. rtlStrToUnicode(1, &v.c, len, val);
  2840. argsig++;
  2841. break;
  2842. case 'L':
  2843. if (strncmp(argsig, "Ljava/lang/String;", 18) == 0)
  2844. {
  2845. argsig += 18;
  2846. unsigned unicodeChars;
  2847. UChar *unicode;
  2848. rtlStrToUnicodeX(unicodeChars, unicode, len, val);
  2849. v.l = JNIenv->NewString(unicode, unicodeChars);
  2850. rtlFree(unicode);
  2851. break;
  2852. }
  2853. // fall into ...
  2854. default:
  2855. typeError("STRING");
  2856. break;
  2857. }
  2858. addArg(v);
  2859. }
  2860. virtual void bindVStringParam(const char *name, const char *val)
  2861. {
  2862. bindStringParam(name, strlen(val), val);
  2863. }
  2864. virtual void bindUTF8Param(const char *name, size32_t numchars, const char *val)
  2865. {
  2866. jvalue v;
  2867. switch(*argsig)
  2868. {
  2869. case 'C':
  2870. rtlUtf8ToUnicode(1, &v.c, numchars, val);
  2871. argsig++;
  2872. break;
  2873. case 'L':
  2874. if (strncmp(argsig, "Ljava/lang/String;", 18) == 0)
  2875. {
  2876. argsig += 18;
  2877. unsigned unicodeChars;
  2878. UChar *unicode;
  2879. rtlUtf8ToUnicodeX(unicodeChars, unicode, numchars, val);
  2880. v.l = JNIenv->NewString(unicode, unicodeChars);
  2881. rtlFree(unicode);
  2882. break;
  2883. }
  2884. // fall into ...
  2885. default:
  2886. typeError("UTF8");
  2887. break;
  2888. }
  2889. addArg(v);
  2890. }
  2891. virtual void bindUnicodeParam(const char *name, size32_t numchars, const UChar *val)
  2892. {
  2893. jvalue v;
  2894. switch(*argsig)
  2895. {
  2896. case 'C':
  2897. rtlUnicodeToUnicode(1, &v.c, numchars, val);
  2898. argsig++;
  2899. break;
  2900. case 'L':
  2901. if (strncmp(argsig, "Ljava/lang/String;", 18) == 0)
  2902. {
  2903. argsig += 18;
  2904. v.l = JNIenv->NewString(val, numchars);
  2905. break;
  2906. }
  2907. // fall into ...
  2908. default:
  2909. typeError("UNICODE");
  2910. break;
  2911. }
  2912. addArg(v);
  2913. }
  2914. virtual void bindSetParam(const char *name, int _elemType, size32_t elemSize, bool isAll, size32_t totalBytes, const void *setData)
  2915. {
  2916. jvalue v;
  2917. if (*argsig != '[')
  2918. typeError("SET");
  2919. argsig++;
  2920. type_t elemType = (type_t) _elemType;
  2921. int numElems = totalBytes / elemSize;
  2922. switch(*argsig)
  2923. {
  2924. case 'Z':
  2925. checkType(type_boolean, sizeof(jboolean), elemType, elemSize);
  2926. v.l = JNIenv->NewBooleanArray(numElems);
  2927. sharedCtx->JNIenv->SetBooleanArrayRegion((jbooleanArray) v.l, 0, numElems, (jboolean *) setData);
  2928. break;
  2929. case 'B':
  2930. checkType(type_int, sizeof(jbyte), elemType, elemSize);
  2931. v.l = JNIenv->NewByteArray(numElems);
  2932. sharedCtx->JNIenv->SetByteArrayRegion((jbyteArray) v.l, 0, numElems, (jbyte *) setData);
  2933. break;
  2934. case 'C':
  2935. // we COULD map to a set of string1, but is there any point?
  2936. typeError("");
  2937. break;
  2938. case 'S':
  2939. checkType(type_int, sizeof(jshort), elemType, elemSize);
  2940. v.l = JNIenv->NewShortArray(numElems);
  2941. sharedCtx->JNIenv->SetShortArrayRegion((jshortArray) v.l, 0, numElems, (jshort *) setData);
  2942. break;
  2943. case 'I':
  2944. checkType(type_int, sizeof(jint), elemType, elemSize);
  2945. v.l = JNIenv->NewIntArray(numElems);
  2946. JNIenv->SetIntArrayRegion((jintArray) v.l, 0, numElems, (jint *) setData);
  2947. break;
  2948. case 'J':
  2949. checkType(type_int, sizeof(jlong), elemType, elemSize);
  2950. v.l = JNIenv->NewLongArray(numElems);
  2951. JNIenv->SetLongArrayRegion((jlongArray) v.l, 0, numElems, (jlong *) setData);
  2952. break;
  2953. case 'F':
  2954. checkType(type_real, sizeof(jfloat), elemType, elemSize);
  2955. v.l = sharedCtx->JNIenv->NewFloatArray(numElems);
  2956. JNIenv->SetFloatArrayRegion((jfloatArray) v.l, 0, numElems, (jfloat *) setData);
  2957. break;
  2958. case 'D':
  2959. checkType(type_real, sizeof(jdouble), elemType, elemSize);
  2960. v.l = sharedCtx->JNIenv->NewDoubleArray(numElems);
  2961. JNIenv->SetDoubleArrayRegion((jdoubleArray) v.l, 0, numElems, (jdouble *) setData);
  2962. break;
  2963. case 'L':
  2964. if (strncmp(argsig, "Ljava/lang/String;", 18) == 0)
  2965. {
  2966. argsig += 17; // Yes, 17, because we increment again at the end of the case
  2967. const byte *inData = (const byte *) setData;
  2968. const byte *endData = inData + totalBytes;
  2969. if (elemSize == UNKNOWN_LENGTH)
  2970. {
  2971. numElems = 0;
  2972. // Will need 2 passes to work out how many elements there are in the set :(
  2973. while (inData < endData)
  2974. {
  2975. int thisSize;
  2976. switch (elemType)
  2977. {
  2978. case type_varstring:
  2979. thisSize = strlen((const char *) inData) + 1;
  2980. break;
  2981. case type_string:
  2982. thisSize = * (size32_t *) inData + sizeof(size32_t);
  2983. break;
  2984. case type_unicode:
  2985. thisSize = (* (size32_t *) inData) * sizeof(UChar) + sizeof(size32_t);
  2986. break;
  2987. case type_utf8:
  2988. thisSize = rtlUtf8Size(* (size32_t *) inData, inData + sizeof(size32_t)) + sizeof(size32_t);;
  2989. break;
  2990. default:
  2991. typeError("STRING");
  2992. }
  2993. inData += thisSize;
  2994. numElems++;
  2995. }
  2996. inData = (const byte *) setData;
  2997. }
  2998. int idx = 0;
  2999. v.l = JNIenv->NewObjectArray(numElems, JNIenv->FindClass("java/lang/String"), NULL);
  3000. while (inData < endData)
  3001. {
  3002. jstring thisElem;
  3003. size32_t thisSize = elemSize;
  3004. switch (elemType)
  3005. {
  3006. case type_varstring:
  3007. {
  3008. size32_t numChars = strlen((const char *) inData);
  3009. unsigned unicodeChars;
  3010. rtlDataAttr unicode;
  3011. rtlStrToUnicodeX(unicodeChars, unicode.refustr(), numChars, (const char *) inData);
  3012. thisElem = JNIenv->NewString(unicode.getustr(), unicodeChars);
  3013. if (elemSize == UNKNOWN_LENGTH)
  3014. thisSize = numChars + 1;
  3015. break;
  3016. }
  3017. case type_string:
  3018. {
  3019. if (elemSize == UNKNOWN_LENGTH)
  3020. {
  3021. thisSize = * (size32_t *) inData;
  3022. inData += sizeof(size32_t);
  3023. }
  3024. unsigned unicodeChars;
  3025. rtlDataAttr unicode;
  3026. rtlStrToUnicodeX(unicodeChars, unicode.refustr(), thisSize, (const char *) inData);
  3027. thisElem = JNIenv->NewString(unicode.getustr(), unicodeChars);
  3028. break;
  3029. }
  3030. case type_unicode:
  3031. {
  3032. if (elemSize == UNKNOWN_LENGTH)
  3033. {
  3034. thisSize = (* (size32_t *) inData) * sizeof(UChar); // NOTE - it's in chars...
  3035. inData += sizeof(size32_t);
  3036. }
  3037. thisElem = JNIenv->NewString((const UChar *) inData, thisSize / sizeof(UChar));
  3038. break;
  3039. }
  3040. case type_utf8:
  3041. {
  3042. assertex (elemSize == UNKNOWN_LENGTH);
  3043. size32_t numChars = * (size32_t *) inData;
  3044. inData += sizeof(size32_t);
  3045. unsigned unicodeChars;
  3046. rtlDataAttr unicode;
  3047. rtlUtf8ToUnicodeX(unicodeChars, unicode.refustr(), numChars, (const char *) inData);
  3048. thisElem = JNIenv->NewString(unicode.getustr(), unicodeChars);
  3049. thisSize = rtlUtf8Size(numChars, inData);
  3050. break;
  3051. }
  3052. default:
  3053. typeError("STRING");
  3054. }
  3055. checkException();
  3056. inData += thisSize;
  3057. JNIenv->SetObjectArrayElement((jobjectArray) v.l, idx, thisElem);
  3058. JNIenv->DeleteLocalRef(thisElem);
  3059. idx++;
  3060. }
  3061. }
  3062. else
  3063. typeError("");
  3064. break;
  3065. default:
  3066. throwUnexpected();
  3067. }
  3068. argsig++;
  3069. addArg(v);
  3070. }
  3071. virtual void bindRowParam(const char *name, IOutputMetaData & metaVal, const byte *val) override
  3072. {
  3073. if (*argsig != 'L') // should tell us the type of the object we need to create to pass in
  3074. typeError("RECORD");
  3075. // Class name is from the char after the L up to the first ;
  3076. const char *tail = strchr(argsig, ';');
  3077. if (!tail)
  3078. typeError("RECORD");
  3079. StringAttr className(argsig+1, tail - (argsig+1));
  3080. argsig = tail+1;
  3081. const RtlTypeInfo *typeInfo = metaVal.queryTypeInfo();
  3082. assertex(typeInfo);
  3083. RtlFieldStrInfo dummyField("<row>", NULL, typeInfo);
  3084. JavaObjectBuilder javaBuilder(JNIenv, &dummyField, loadClass(className));
  3085. typeInfo->process(val, val, &dummyField, javaBuilder); // Creates a java object from the incoming ECL row
  3086. jvalue v;
  3087. v.l = javaBuilder.getObject();
  3088. addArg(v);
  3089. }
  3090. virtual IInterface *bindParamWriter(IInterface *esdl, const char *esdlservice, const char *esdltype, const char *name)
  3091. {
  3092. if (*argsig != 'L') // should tell us the type of the object we need to create to pass in
  3093. typeError("OBJECT");
  3094. // Class name is from the char after the L up to the first ;
  3095. const char *tail = strchr(argsig, ';');
  3096. if (!tail)
  3097. typeError("OBJECT");
  3098. StringAttr className(argsig+1, tail - (argsig+1));
  3099. argsig = tail+1;
  3100. Owned<JavaXmlBuilder> writer = new JavaXmlBuilder(JNIenv, dynamic_cast<IEsdlDefinition*>(esdl), esdlservice, esdltype);
  3101. writer->initWriter();
  3102. return (IXmlWriter*)writer.getClear();
  3103. }
  3104. virtual void paramWriterCommit(IInterface *writer)
  3105. {
  3106. JavaXmlBuilder *javaWriter = dynamic_cast<JavaXmlBuilder*>(writer);
  3107. if (!javaWriter)
  3108. throw MakeStringException(0, "javaembed: Invalid object writer for %s", signature);
  3109. jvalue v;
  3110. v.l = javaWriter->getObject();
  3111. addArg(v);
  3112. }
  3113. virtual void bindDatasetParam(const char *name, IOutputMetaData & metaVal, IRowStream * val)
  3114. {
  3115. jvalue v;
  3116. char argsigStart = *argsig;
  3117. switch (argsigStart)
  3118. {
  3119. case '[':
  3120. case '<':
  3121. ++argsig;
  3122. break;
  3123. case 'L':
  3124. if (strncmp(argsig, "Ljava/util/Iterator<", 20) == 0)
  3125. {
  3126. argsig += 20;
  3127. break;
  3128. }
  3129. /* no break */
  3130. default:
  3131. typeError("DATASET");
  3132. }
  3133. if (*argsig != 'L') // should tell us the type of the object we need to create to pass in
  3134. typeError("DATASET");
  3135. // Class name is from the char after the L up to the first ;
  3136. const char *tail = strchr(argsig, ';');
  3137. if (!tail)
  3138. typeError("RECORD");
  3139. StringAttr className(argsig+1, tail - (argsig+1));
  3140. argsig = tail+1;
  3141. if (argsigStart=='L')
  3142. {
  3143. if (argsig[0] != '>' || argsig[1] != ';')
  3144. typeError("DATASET");
  3145. argsig += 2;
  3146. }
  3147. if (argsigStart=='[')
  3148. {
  3149. // Pass in an array of objects
  3150. PointerArrayOf<_jobject> allRows;
  3151. const RtlTypeInfo *typeInfo = metaVal.queryTypeInfo();
  3152. assertex(typeInfo);
  3153. RtlFieldStrInfo dummyField("<row>", NULL, typeInfo);
  3154. jclass Class = loadClass(className);
  3155. JavaObjectBuilder javaBuilder(JNIenv, &dummyField, Class);
  3156. for (;;)
  3157. {
  3158. roxiemem::OwnedConstRoxieRow thisRow = val->ungroupedNextRow();
  3159. if (!thisRow)
  3160. break;
  3161. const byte *brow = (const byte *) thisRow.get();
  3162. typeInfo->process(brow, brow, &dummyField, javaBuilder); // Creates a java object from the incoming ECL row
  3163. allRows.append(javaBuilder.getObject());
  3164. }
  3165. jobjectArray array = JNIenv->NewObjectArray(allRows.length(), Class, NULL);
  3166. ForEachItemIn(idx, allRows)
  3167. {
  3168. JNIenv->SetObjectArrayElement(array, idx, allRows.item(idx));
  3169. }
  3170. v.l = array;
  3171. }
  3172. else
  3173. {
  3174. // Pass in an iterator
  3175. // Create a java object of type com.HPCCSystems.HpccUtils - this acts as a proxy for the iterator
  3176. JNIenv->ExceptionClear();
  3177. jclass proxyClass = JNIenv->FindClass("com/HPCCSystems/HpccUtils");
  3178. checkException();
  3179. jmethodID constructor = JNIenv->GetMethodID(proxyClass, "<init>", "(JLjava/lang/String;)V");
  3180. checkException();
  3181. jvalue param;
  3182. const RtlTypeInfo *typeInfo = metaVal.queryTypeInfo();
  3183. ECLDatasetIterator *iterator = new ECLDatasetIterator(JNIenv, typeInfo, loadClass(className), val);
  3184. param.j = (jlong) iterator;
  3185. iterators.append(*iterator);
  3186. jobject proxy = JNIenv->NewObject(proxyClass, constructor, param, JNIenv->NewStringUTF(helperLibraryName));
  3187. checkException();
  3188. v.l = proxy;
  3189. }
  3190. addArg(v);
  3191. }
  3192. virtual void writeResult(IInterface *esdl, const char *esdlservice, const char *esdltype, IInterface *writer)
  3193. {
  3194. return sharedCtx->writeObjectResult(result.l, dynamic_cast<IEsdlDefinition*>(esdl), esdlservice, esdltype, dynamic_cast<IXmlWriter*>(writer));
  3195. }
  3196. virtual void importFunction(size32_t lenChars, const char *utf) override
  3197. {
  3198. if (!javaClass)
  3199. loadFunction(lenChars, utf, classpath, 0, nullptr);
  3200. reinit();
  3201. }
  3202. virtual void callFunction()
  3203. {
  3204. if (*argsig != ')')
  3205. throw MakeStringException(0, "javaembed: Too few ECL parameters passed for Java signature %s", signature);
  3206. JNIenv->ExceptionClear();
  3207. if (nonStatic)
  3208. {
  3209. if (!instance)
  3210. throw MakeStringException(0, "javaembed: non static member function %s called, but no instance available", methodName.get()); // Should never happen
  3211. switch (*returnType)
  3212. {
  3213. case 'C': result.c = JNIenv->CallCharMethodA(instance, javaMethodID, args); break;
  3214. case 'Z': result.z = JNIenv->CallBooleanMethodA(instance, javaMethodID, args); break;
  3215. case 'J': result.j = JNIenv->CallLongMethodA(instance, javaMethodID, args); break;
  3216. case 'F': result.f = JNIenv->CallFloatMethodA(instance, javaMethodID, args); break;
  3217. case 'D': result.d = JNIenv->CallDoubleMethodA(instance, javaMethodID, args); break;
  3218. case 'I': result.i = JNIenv->CallIntMethodA(instance, javaMethodID, args); break;
  3219. case 'S': result.s = JNIenv->CallShortMethodA(instance, javaMethodID, args); break;
  3220. case 'B': result.s = JNIenv->CallByteMethodA(instance, javaMethodID, args); break;
  3221. case '[':
  3222. case 'L': result.l = JNIenv->CallObjectMethodA(instance, javaMethodID, args); break;
  3223. default: throwUnexpected();
  3224. }
  3225. }
  3226. else
  3227. {
  3228. switch (*returnType)
  3229. {
  3230. case 'C': result.c = JNIenv->CallStaticCharMethodA(javaClass, javaMethodID, args); break;
  3231. case 'Z': result.z = JNIenv->CallStaticBooleanMethodA(javaClass, javaMethodID, args); break;
  3232. case 'J': result.j = JNIenv->CallStaticLongMethodA(javaClass, javaMethodID, args); break;
  3233. case 'F': result.f = JNIenv->CallStaticFloatMethodA(javaClass, javaMethodID, args); break;
  3234. case 'D': result.d = JNIenv->CallStaticDoubleMethodA(javaClass, javaMethodID, args); break;
  3235. case 'I': result.i = JNIenv->CallStaticIntMethodA(javaClass, javaMethodID, args); break;
  3236. case 'S': result.s = JNIenv->CallStaticShortMethodA(javaClass, javaMethodID, args); break;
  3237. case 'B': result.s = JNIenv->CallStaticByteMethodA(javaClass, javaMethodID, args); break;
  3238. case '[':
  3239. case 'L': result.l = JNIenv->CallStaticObjectMethodA(javaClass, javaMethodID, args); break;
  3240. default: throwUnexpected();
  3241. }
  3242. }
  3243. checkException();
  3244. }
  3245. virtual void compileEmbeddedScript(size32_t lenChars, const char *_script)
  3246. {
  3247. throwUnexpected();
  3248. }
  3249. virtual void loadCompiledScript(size32_t bytecodeLen, const void *bytecode) override
  3250. {
  3251. if (!javaClass)
  3252. {
  3253. MemoryBuffer b;
  3254. b.setBuffer(bytecodeLen, (void *) bytecode, false);
  3255. b.setEndian(__BIG_ENDIAN);
  3256. uint32_t siglen; b.read(siglen);
  3257. const char *sig = (const char *) b.readDirect(siglen);
  3258. loadFunction(siglen, sig, classpath, bytecodeLen, (const byte *) bytecode);
  3259. }
  3260. reinit();
  3261. }
  3262. virtual void enter() override
  3263. {
  3264. // If we rejig codegen to only call loadCompiledScript etc at construction time, then this will need to do the reinit()
  3265. // until we do, it's too early
  3266. // Create a new frame for local references and increase the capacity
  3267. // of those references to 64 (default is 16)
  3268. JNIenv->PushLocalFrame(64);
  3269. }
  3270. virtual void exit() override
  3271. {
  3272. if (persistMode == persistNone && instance != nullptr)
  3273. {
  3274. JNIenv->DeleteGlobalRef(instance);
  3275. instance = nullptr;
  3276. }
  3277. JNIenv->PopLocalFrame(nullptr);
  3278. #ifdef CHECK_JNI
  3279. forceGC(JNIenv);
  3280. #endif
  3281. }
  3282. protected:
  3283. __declspec(noreturn) void typeError(const char *ECLtype) __attribute__((noreturn))
  3284. {
  3285. const char *javaType;
  3286. int javaLen = 0;
  3287. switch (*argsig)
  3288. {
  3289. case 'Z': javaType = "boolean"; break;
  3290. case 'B': javaType = "byte"; break;
  3291. case 'C': javaType = "char"; break;
  3292. case 'S': javaType = "short"; break;
  3293. case 'I': javaType = "int"; break;
  3294. case 'J': javaType = "long"; break;
  3295. case 'F': javaType = "float"; break;
  3296. case 'D': javaType = "double"; break;
  3297. case '[': javaType = "array"; break;
  3298. case 'L':
  3299. {
  3300. javaType = argsig+1;
  3301. const char *semi = strchr(argsig, ';');
  3302. if (semi)
  3303. javaLen = semi - javaType;
  3304. break;
  3305. }
  3306. case ')':
  3307. throw MakeStringException(0, "javaembed: Too many ECL parameters passed for Java signature %s", signature);
  3308. default:
  3309. throw MakeStringException(0, "javaembed: Unrecognized character %c in java signature %s", *argsig, signature);
  3310. }
  3311. if (!javaLen)
  3312. javaLen = strlen(argsig);
  3313. throw MakeStringException(0, "javaembed: ECL type %s cannot be passed to Java type %.*s", ECLtype, javaLen, javaType);
  3314. }
  3315. void addArg(jvalue &arg)
  3316. {
  3317. assertex(argcount < MAX_JNI_ARGS);
  3318. args[argcount] = arg;
  3319. argcount++;
  3320. }
  3321. size32_t getRowResult(jobject result, ARowBuilder &builder)
  3322. {
  3323. const RtlTypeInfo *typeInfo = builder.queryAllocator()->queryOutputMeta()->queryTypeInfo();
  3324. assertex(typeInfo);
  3325. RtlFieldStrInfo dummyField("<row>", NULL, typeInfo);
  3326. JavaRowBuilder javaRowBuilder(JNIenv, &dummyField, result);
  3327. return typeInfo->build(builder, 0, &dummyField, javaRowBuilder);
  3328. }
  3329. jclass loadClass(const char *className)
  3330. {
  3331. JNIenv->ExceptionClear();
  3332. jmethodID loadClassMethod = JNIenv->GetMethodID(JNIenv->GetObjectClass(classLoader), "loadClass","(Ljava/lang/String;)Ljava/lang/Class;");
  3333. checkException();
  3334. jstring classNameString = JNIenv->NewStringUTF(className);
  3335. checkException();
  3336. jclass Class = (jclass) JNIenv->CallObjectMethod(classLoader, loadClassMethod, classNameString);
  3337. checkException();
  3338. return Class;
  3339. }
  3340. const char *queryReportName()
  3341. {
  3342. const char *report = strrchr(importName.get(), '/');
  3343. if (report)
  3344. report++;
  3345. else
  3346. report = importName.get();
  3347. return report;
  3348. }
  3349. void checkException()
  3350. {
  3351. if (JNIenv->ExceptionCheck())
  3352. {
  3353. jthrowable exception = JNIenv->ExceptionOccurred();
  3354. JNIenv->ExceptionClear();
  3355. jclass throwableClass = JNIenv->FindClass("java/lang/Throwable");
  3356. jmethodID throwableToString = JNIenv->GetMethodID(throwableClass, "toString", "()Ljava/lang/String;");
  3357. jstring cause = (jstring) JNIenv->CallObjectMethod(exception, throwableToString);
  3358. JNIenv->ExceptionClear(); // The above function sometimes sets exception flag, no idea why. Causes unwanted tracing in checking mode.
  3359. const char *text = JNIenv->GetStringUTFChars(cause, 0);
  3360. VStringBuffer message("javaembed: In method %s: %s", queryReportName(), text);
  3361. JNIenv->ReleaseStringUTFChars(cause, text);
  3362. JNIenv->ExceptionClear();
  3363. rtlFail(0, message.str());
  3364. }
  3365. }
  3366. void checkException(const char *text)
  3367. {
  3368. if (JNIenv->ExceptionCheck())
  3369. {
  3370. JNIenv->ExceptionClear();
  3371. VStringBuffer message("javaembed: In method %s: %s", queryReportName(), text);
  3372. rtlFail(0, message.str());
  3373. }
  3374. }
  3375. bool checkException(StringBuffer &message)
  3376. {
  3377. if (JNIenv->ExceptionCheck())
  3378. {
  3379. jthrowable exception = JNIenv->ExceptionOccurred();
  3380. JNIenv->ExceptionClear();
  3381. jclass throwableClass = JNIenv->FindClass("java/lang/Throwable");
  3382. jmethodID throwableToString = JNIenv->GetMethodID(throwableClass, "toString", "()Ljava/lang/String;");
  3383. jstring cause = (jstring) JNIenv->CallObjectMethod(exception, throwableToString);
  3384. const char *text = JNIenv->GetStringUTFChars(cause, 0);
  3385. message.append(text);
  3386. JNIenv->ReleaseStringUTFChars(cause, text);
  3387. return true;
  3388. }
  3389. return false;
  3390. }
  3391. jobject createThreadClassLoader(const char *classPath, size32_t bytecodeLen, const byte *bytecode)
  3392. {
  3393. if (bytecodeLen || (classPath && *classPath))
  3394. {
  3395. jclass URLcls = JNIenv->FindClass("java/net/URL");
  3396. checkException();
  3397. jmethodID URLclsMid = JNIenv->GetMethodID(URLcls, "<init>","(Ljava/lang/String;)V");
  3398. checkException();
  3399. StringArray paths;
  3400. paths.appendList(classPath, ";"); // NOTE - as we need to be able to include : in the urls, we can't use ENVSEP here
  3401. jobjectArray URLArray = JNIenv->NewObjectArray(paths.length(), URLcls, NULL);
  3402. ForEachItemIn(idx, paths)
  3403. {
  3404. StringBuffer usepath;
  3405. const char *path = paths.item(idx);
  3406. if (!strchr(path, ':'))
  3407. usepath.append("file:");
  3408. usepath.append(path);
  3409. jstring jstr = JNIenv->NewStringUTF(usepath.str());
  3410. checkException();
  3411. jobject URLobj = JNIenv->NewObject(URLcls, URLclsMid, jstr);
  3412. checkException();
  3413. JNIenv->SetObjectArrayElement(URLArray, idx, URLobj);
  3414. JNIenv->DeleteLocalRef(URLobj);
  3415. JNIenv->DeleteLocalRef(jstr);
  3416. }
  3417. checkException();
  3418. jclass customLoaderClass = JNIenv->FindClass("com/HPCCSystems/HpccClassLoader");
  3419. checkException("Unable to find class HpccClassLoader - is classpath set properly?");
  3420. jmethodID newInstance = JNIenv->GetStaticMethodID(customLoaderClass, "newInstance","([Ljava/net/URL;Ljava/lang/ClassLoader;IJLjava/lang/String;)Lcom/HPCCSystems/HpccClassLoader;");
  3421. checkException();
  3422. jobject helperName = JNIenv->NewStringUTF(helperLibraryName);
  3423. checkException();
  3424. jobject contextClassLoaderObj = JNIenv->CallStaticObjectMethod(customLoaderClass, newInstance, URLArray, sharedCtx->getSystemClassLoader(), bytecodeLen, (uint64_t) bytecode, helperName);
  3425. checkException();
  3426. assertex(contextClassLoaderObj);
  3427. return contextClassLoaderObj;
  3428. }
  3429. else
  3430. {
  3431. return sharedCtx->getSystemClassLoader();
  3432. }
  3433. }
  3434. void loadFunction(size32_t lenChars, const char *utf, const char *classpath, size32_t bytecodeLen, const byte *bytecode)
  3435. {
  3436. size32_t bytes = rtlUtf8Size(lenChars, utf);
  3437. importName.set(utf, bytes);
  3438. classLoader = JNIenv->NewGlobalRef(createThreadClassLoader(classpath, bytecodeLen, bytecode));
  3439. sharedCtx->setThreadClassLoader(classLoader);
  3440. // Name should be in the form class.method:signature
  3441. const char *funcname = strrchr(importName, '.');
  3442. if (!funcname)
  3443. throw MakeStringException(MSGAUD_user, 0, "javaembed: Invalid import name %s - Expected classname.methodname:signature", importName.str());
  3444. signature = strchr(funcname, ':');
  3445. if (!signature)
  3446. throw MakeStringException(MSGAUD_user, 0, "javaembed: Invalid import name %s - Expected classname.methodname:signature", importName.str());
  3447. StringBuffer classname(funcname-importName, importName);
  3448. // While it's probably preferred for people to use . as the separator in nested classes (to match java import statement),
  3449. // we accept / too (to match what you would see in the jar)
  3450. classname.replace('/', '.');
  3451. funcname++; // skip the '.'
  3452. methodName.set(funcname, signature-funcname);
  3453. signature++; // skip the ':'
  3454. if (*signature == '@') // indicates a non-static method
  3455. {
  3456. nonStatic = true;
  3457. signature++;
  3458. }
  3459. // We need to patch up the provided signature - any instances of <classname; need to be replaced by Ljava.utils.iterator
  3460. StringBuffer javaSignature;
  3461. const char *finger = signature;
  3462. while (*finger)
  3463. {
  3464. if (*finger == '<')
  3465. {
  3466. // If there is a corresponding >, assume it's the 'extended' form and just strip out the bit from < to >
  3467. const char *close = strchr(finger, '>');
  3468. if (close)
  3469. finger = close;
  3470. else
  3471. {
  3472. javaSignature.append("Ljava/util/Iterator;");
  3473. finger = strchr(finger, ';');
  3474. if (!finger)
  3475. throw MakeStringException(MSGAUD_user, 0, "javaembed: Invalid java function signature %s", signature);
  3476. }
  3477. }
  3478. else
  3479. javaSignature.append(*finger);
  3480. finger++;
  3481. }
  3482. jmethodID loadClassMethod = JNIenv->GetMethodID(JNIenv->GetObjectClass(classLoader), "loadClass","(Ljava/lang/String;)Ljava/lang/Class;");
  3483. jstring methodString = JNIenv->NewStringUTF(classname);
  3484. javaClass = (jclass) JNIenv->CallObjectMethod(classLoader, loadClassMethod, methodString);
  3485. StringBuffer message;
  3486. if (checkException(message) || !javaClass)
  3487. throw MakeStringException(MSGAUD_user, 0, "javaembed: Failed to resolve class name %s: %s", classname.str(), message.str());
  3488. javaClass = (jclass) JNIenv->NewGlobalRef(javaClass);
  3489. if (nonStatic)
  3490. javaMethodID = JNIenv->GetMethodID(javaClass, methodName, javaSignature);
  3491. else
  3492. javaMethodID = JNIenv->GetStaticMethodID(javaClass, methodName, javaSignature);
  3493. if (checkException(message) || !javaMethodID)
  3494. throw MakeStringException(MSGAUD_user, 0, "javaembed: Failed to resolve method name %s with signature %s: %s", methodName.str(), signature, message.str());
  3495. returnType = strrchr(signature, ')');
  3496. assertex(returnType); // Otherwise how did Java accept it??
  3497. returnType++;
  3498. }
  3499. JavaThreadContext *sharedCtx = nullptr;
  3500. JNIEnv *JNIenv = nullptr;
  3501. jvalue result = {0};
  3502. StringAttr classpath;
  3503. IArrayOf<ECLDatasetIterator> iterators; // to make sure they get freed
  3504. bool nonStatic = false;
  3505. jobject instance = nullptr; // class instance of object to call methods on
  3506. PersistMode persistMode = persistNone; // Defines the lifetime of the java object for which this is called.
  3507. // The following members are set up the first time a method is called only
  3508. IEngineContext *engine = nullptr;
  3509. jclass javaClass = nullptr;
  3510. jobject classLoader = nullptr;
  3511. jmethodID javaMethodID = nullptr;
  3512. StringAttr methodName;
  3513. StringAttr importName;
  3514. const char *returnType = nullptr; // A pointer within importName
  3515. const char *signature = nullptr; // A pointer within importName
  3516. // These point to the current arg/signature byte as we are binding
  3517. int argcount = 0;
  3518. jvalue args[MAX_JNI_ARGS];
  3519. const char *argsig = nullptr; // A pointer within signature
  3520. void reinit()
  3521. {
  3522. argcount = 0;
  3523. argsig = signature;
  3524. assertex(*argsig == '(');
  3525. argsig++;
  3526. if (nonStatic && !instance)
  3527. {
  3528. jmethodID constructor = JNIenv->GetMethodID(javaClass, "<init>", "()V");
  3529. checkException("Parameterless constructor required");
  3530. // If the persist scope is global, query, or workunit, we may want to use a pre-existing object
  3531. StringBuffer scopeKey;
  3532. switch (persistMode)
  3533. {
  3534. case persistGlobal:
  3535. scopeKey.set("global");
  3536. break;
  3537. case persistWorkunit:
  3538. engine->getQueryId(scopeKey, true);
  3539. break;
  3540. case persistQuery:
  3541. engine->getQueryId(scopeKey, false);
  3542. break;
  3543. }
  3544. if (scopeKey.length())
  3545. {
  3546. bool isNew;
  3547. instance = globalState->getGlobalObject(scopeKey, JNIenv, javaClass, constructor, isNew);
  3548. if (isNew && engine)
  3549. engine->onTermination(JavaGlobalState::unregister, scopeKey.str(), persistMode==persistWorkunit);
  3550. }
  3551. else
  3552. {
  3553. instance = JNIenv->NewGlobalRef(JNIenv->NewObject(javaClass, constructor));
  3554. checkException();
  3555. }
  3556. }
  3557. }
  3558. };
  3559. static __thread JavaThreadContext* threadContext; // We reuse per thread, for speed
  3560. static __thread ThreadTermFunc threadHookChain;
  3561. static void releaseContext()
  3562. {
  3563. if (threadContext)
  3564. {
  3565. delete threadContext;
  3566. threadContext = NULL;
  3567. }
  3568. if (threadHookChain)
  3569. {
  3570. (*threadHookChain)();
  3571. threadHookChain = NULL;
  3572. }
  3573. }
  3574. static JavaThreadContext *queryContext()
  3575. {
  3576. if (!threadContext)
  3577. {
  3578. threadContext = new JavaThreadContext;
  3579. threadHookChain = addThreadTermFunc(releaseContext);
  3580. }
  3581. return threadContext;
  3582. }
  3583. static JNIEnv *queryJNIEnv()
  3584. {
  3585. return queryContext()->JNIenv;
  3586. }
  3587. class JavaEmbedServiceContext : public CInterfaceOf<IEmbedServiceContext>
  3588. {
  3589. public:
  3590. JavaEmbedServiceContext(JavaThreadContext *_sharedCtx, const char *service, const char *_options)
  3591. : sharedCtx(_sharedCtx), Class(0), options(_options), className(service), object(0)
  3592. {
  3593. StringArray opts;
  3594. opts.appendList(options, ",");
  3595. ForEachItemIn(idx, opts)
  3596. {
  3597. const char *opt = opts.item(idx);
  3598. const char *val = strchr(opt, '=');
  3599. if (val)
  3600. {
  3601. StringBuffer optName(val-opt, opt);
  3602. val++;
  3603. if (strieq(optName, "classpath"))
  3604. classpath.set(val);
  3605. else
  3606. throw MakeStringException(0, "javaembed: Unknown option %s", optName.str());
  3607. }
  3608. }
  3609. }
  3610. ~JavaEmbedServiceContext()
  3611. {
  3612. if (object)
  3613. sharedCtx->JNIenv->DeleteGlobalRef(object);
  3614. if (Class)
  3615. sharedCtx->JNIenv->DeleteGlobalRef(Class);
  3616. }
  3617. void init()
  3618. {
  3619. jobject classLoader = sharedCtx->getThreadClassLoader();
  3620. checkException();
  3621. jmethodID loadClassMethod = sharedCtx->JNIenv->GetMethodID(sharedCtx->JNIenv->GetObjectClass(classLoader), "loadClass","(Ljava/lang/String;)Ljava/lang/Class;");
  3622. checkException();
  3623. jstring methodString = sharedCtx->JNIenv->NewStringUTF(className);
  3624. checkException();
  3625. Class = (jclass) sharedCtx->JNIenv->NewGlobalRef(sharedCtx->JNIenv->CallObjectMethod(classLoader, loadClassMethod, methodString));
  3626. checkException();
  3627. jmethodID constructor = sharedCtx->JNIenv->GetMethodID(Class, "<init>", "()V");
  3628. checkException();
  3629. object = sharedCtx->JNIenv->NewGlobalRef(sharedCtx->JNIenv->NewObject(Class, constructor));
  3630. checkException();
  3631. }
  3632. virtual IEmbedFunctionContext *createFunctionContext(const char *function)
  3633. {
  3634. if (!object)
  3635. return NULL;
  3636. Owned<JavaEmbedImportContext> fctx = new JavaEmbedImportContext(nullptr, queryContext(), object, 0, options);
  3637. fctx->importFunction(rtlUtf8Length(strlen(function), function), function);
  3638. return fctx.getClear();
  3639. }
  3640. void checkException()
  3641. {
  3642. javaembed::checkException(sharedCtx->JNIenv, false);
  3643. }
  3644. protected:
  3645. JavaThreadContext *sharedCtx;
  3646. StringBuffer className;
  3647. jclass Class;
  3648. jobject object;
  3649. StringAttr classpath;
  3650. StringAttr options;
  3651. };
  3652. class JavaEmbedContext : public CInterfaceOf<IEmbedContext>
  3653. {
  3654. public:
  3655. virtual IEmbedFunctionContext *createFunctionContext(unsigned flags, const char *options) override
  3656. {
  3657. return createFunctionContextEx(nullptr, nullptr, flags, options);
  3658. }
  3659. virtual IEmbedFunctionContext *createFunctionContextEx(ICodeContext * ctx, const IThorActivityContext *activityCtx, unsigned flags, const char *options) override
  3660. {
  3661. return new JavaEmbedImportContext(ctx, queryContext(), nullptr, flags, options);
  3662. }
  3663. virtual IEmbedServiceContext *createServiceContext(const char *service, unsigned flags, const char *options) override
  3664. {
  3665. Owned<JavaEmbedServiceContext> serviceContext = new JavaEmbedServiceContext(queryContext(), service, options);
  3666. serviceContext->init();
  3667. return serviceContext.getClear();
  3668. }
  3669. };
  3670. extern DECL_EXPORT IEmbedContext* getEmbedContext()
  3671. {
  3672. return new JavaEmbedContext;
  3673. }
  3674. static bool isValidIdentifier(const char *source)
  3675. {
  3676. return isalnum(*source) || *source=='_' || *source=='$' || ::readUtf8Size(source)>1; // This is not strictly accurate but probably good enough
  3677. }
  3678. static bool isFullClassFile(StringBuffer &className, bool &seenPublic, size32_t len, const char *source)
  3679. {
  3680. // A heuristic to determine whether the supplied embedded source is a full class file or just a single method
  3681. // Basically, if we see keyword "class" before we see { then we assume it's a full file
  3682. // Also track whether the public keyword has been supplied
  3683. bool inLineComment = false;
  3684. bool inBlockComment = false;
  3685. seenPublic = false;
  3686. while (len)
  3687. {
  3688. if (inLineComment)
  3689. {
  3690. if (*source=='\n')
  3691. inLineComment = false;
  3692. }
  3693. else if (inBlockComment)
  3694. {
  3695. if (*source=='*' && len > 1 && source[1]=='/')
  3696. {
  3697. inBlockComment = false;
  3698. len--;
  3699. source++;
  3700. }
  3701. }
  3702. else switch(*source)
  3703. {
  3704. case '/':
  3705. if (len > 1)
  3706. {
  3707. if (source[1]=='*')
  3708. {
  3709. inBlockComment = true;
  3710. len--;
  3711. source++;
  3712. }
  3713. else if (source[1]=='/')
  3714. inLineComment = true;
  3715. }
  3716. break;
  3717. case '{':
  3718. return false;
  3719. default:
  3720. if (isValidIdentifier(source))
  3721. {
  3722. const char *start = source;
  3723. while (len && isValidIdentifier(source))
  3724. {
  3725. source+=::readUtf8Size(source);
  3726. len--;
  3727. }
  3728. if (source-start == 5 && memcmp(start, "class", source-start)==0)
  3729. {
  3730. while (len && isspace(*source)) // MORE - a comment between the keyword and the classname will fail - tough.
  3731. {
  3732. source += ::readUtf8Size(source);
  3733. len--;
  3734. }
  3735. start = source;
  3736. while (len && isValidIdentifier(source))
  3737. {
  3738. source += ::readUtf8Size(source);
  3739. len--;
  3740. }
  3741. className.append(source-start, start);
  3742. return true;
  3743. }
  3744. else if (source-start == 6 && memcmp(start, "public", source-start)==0)
  3745. seenPublic = true;
  3746. }
  3747. if (!len)
  3748. return false;
  3749. break;
  3750. }
  3751. source += ::readUtf8Size(source);
  3752. len--;
  3753. }
  3754. // If we get here then it doesn't have a { at all - we COULD say it needs the prototype too but for now, who knows...
  3755. return false;
  3756. }
  3757. static StringBuffer & cleanupJavaError(StringBuffer &ret, const char *err, unsigned lineNumberOffset)
  3758. {
  3759. // Remove filename (as it's generated) and fix up line number. Skip errors that do not have line number in
  3760. const char *colon = strchr(err, ':');
  3761. if (colon && isdigit(colon[1]))
  3762. {
  3763. char *end;
  3764. unsigned lineno = strtoul(colon+1, &end, 10) - lineNumberOffset;
  3765. ret.appendf("(%u,1)%s", lineno, end);
  3766. }
  3767. return ret;
  3768. }
  3769. static void cleanupJavaErrors(StringBuffer &ret, const char *errors, unsigned lineNumberOffset)
  3770. {
  3771. StringArray errlines;
  3772. errlines.appendList(errors, "\n");
  3773. ForEachItemIn(idx, errlines)
  3774. {
  3775. StringBuffer cleaned;
  3776. cleanupJavaError(cleaned, errlines.item(idx), lineNumberOffset);
  3777. if (cleaned.length())
  3778. ret.append(cleaned).append('\n');
  3779. }
  3780. }
  3781. static thread_local unsigned prevHash = 0;
  3782. static thread_local MemoryBuffer prevCompile;
  3783. void doPrecompile(size32_t & __lenResult, void * & __result, const char *funcName, size32_t charsBody, const char * body, const char *argNames, const char *compilerOptions, const char *persistOptions, StringBuffer &errors, bool checking)
  3784. {
  3785. unsigned sizeBody = rtlUtf8Size(charsBody, body); // size in bytes
  3786. unsigned hash = rtlHash32Data(sizeBody,body,0xcafebabe);
  3787. if (hash==prevHash) // Reusing result from the syntax check that normally immediately precedes a precompile
  3788. {
  3789. __lenResult = prevCompile.length();
  3790. __result = prevCompile.detachOwn();
  3791. prevHash = 0;
  3792. return;
  3793. }
  3794. PersistMode persistMode = getPersistMode(persistOptions);
  3795. StringBuffer tmpDirName;
  3796. getTempFilePath(tmpDirName, "javaembed", nullptr);
  3797. tmpDirName.append(PATHSEPCHAR).append("tmp.XXXXXX");
  3798. if (!mkdtemp((char *) tmpDirName.str()))
  3799. throw makeStringExceptionV(0, "Failed to create temporary directory %s (error %d)", tmpDirName.str(), errno);
  3800. Owned<IFile> tempDir = createIFile(tmpDirName);
  3801. StringBuffer classname;
  3802. bool seenPublic = false;
  3803. bool isFullClass = isFullClassFile(classname, seenPublic, charsBody, body); // note - we pass in length in characters, not bytes
  3804. if (!isFullClass)
  3805. classname.set("embed");
  3806. VStringBuffer javafile("%s" PATHSEPSTR "%s.java", tmpDirName.str(), classname.str());
  3807. FILE *source = fopen(javafile.str(), "wt");
  3808. fprintf(source, "package com.HPCCSystems.embed.x%x;\n", hash);
  3809. unsigned lineNumberOffset = 1; // for the /n above
  3810. if (isFullClass)
  3811. fprintf(source, "%.*s", sizeBody, body);
  3812. else
  3813. {
  3814. if (seenPublic)
  3815. fprintf(source, "public class embed\n{\n %.*s\n}", sizeBody, body);
  3816. else
  3817. fprintf(source, "public class embed\n{\n public static %.*s\n}", sizeBody, body);
  3818. lineNumberOffset += 2; // for the /n's above
  3819. }
  3820. fclose(source);
  3821. MemoryBuffer result;
  3822. Owned<IPipeProcess> pipe = createPipeProcess();
  3823. VStringBuffer javac("javac %s %s", isEmptyString(compilerOptions) ? "-g:none" : compilerOptions, javafile.str());
  3824. if (!pipe->run("javac", javac, tmpDirName, false, false, true, 0, false))
  3825. {
  3826. throw makeStringException(0, "Failed to run javac");
  3827. }
  3828. else
  3829. {
  3830. StringBuffer javaErrors;
  3831. Owned<ISimpleReadStream> pipeReader = pipe->getErrorStream();
  3832. readSimpleStream(javaErrors, *pipeReader);
  3833. pipe->closeError();
  3834. unsigned retcode = pipe->wait();
  3835. cleanupJavaErrors(errors, javaErrors, lineNumberOffset);
  3836. if (retcode)
  3837. {
  3838. if (javaErrors.length())
  3839. throw makeStringExceptionV(0, "%s", errors.str());
  3840. else
  3841. throw makeStringException(0, "Failed to precompile java code");
  3842. }
  3843. VStringBuffer mainfile("%s" PATHSEPSTR "%s.class", tmpDirName.str(), classname.str());
  3844. JavaClassReader reader(mainfile);
  3845. if (persistMode > persistThread && (reader.getFlags(funcName) & JavaClassReader::ACC_SYNCHRONIZED)==0)
  3846. errors.appendf("Warning: persist mode set but function is not synchronized\n");
  3847. reader.getEmbedData(result, funcName, true);
  3848. removeFileTraceIfFail(mainfile);
  3849. // Now read nested classes
  3850. Owned<IDirectoryIterator> classFiles = tempDir->directoryFiles("*$*.class",false,false);
  3851. ForEach(*classFiles)
  3852. {
  3853. const char *thisFile = classFiles->query().queryFilename();
  3854. JavaClassReader reader(thisFile);
  3855. reader.getEmbedData(result, nullptr, false);
  3856. removeFileTraceIfFail(thisFile);
  3857. }
  3858. // We could give a warning if persist is set to anything over "thread" and the function we are calling is not synchronized.
  3859. }
  3860. removeFileTraceIfFail(javafile);
  3861. tempDir->remove();
  3862. __lenResult = result.length();
  3863. __result = result.detachOwn();
  3864. }
  3865. extern DECL_EXPORT void precompile(size32_t & __lenResult, void * & __result, const char *funcName, size32_t charsBody, const char * body, const char *argNames, const char *compilerOptions, const char *persistOptions)
  3866. {
  3867. StringBuffer errors;
  3868. doPrecompile(__lenResult, __result, funcName, charsBody, body, argNames, compilerOptions, persistOptions, errors, false);
  3869. }
  3870. extern DECL_EXPORT void syntaxCheck(size32_t & __lenResult, char * & __result, const char *funcname, size32_t charsBody, const char * body, const char *argNames, const char *compilerOptions, const char *persistOptions)
  3871. {
  3872. StringBuffer result;
  3873. try
  3874. {
  3875. size32_t ds;
  3876. rtlDataAttr d;
  3877. StringBuffer errors;
  3878. doPrecompile(ds, d.refdata(), funcname, charsBody, body, argNames, compilerOptions, persistOptions, result, true);
  3879. // Reuse result in the precompile that normally immediately follows
  3880. unsigned sizeBody = rtlUtf8Size(charsBody, body); // size in bytes
  3881. prevHash = rtlHash32Data(sizeBody,body,0xcafebabe);
  3882. prevCompile.setBuffer(ds, d.detachdata(), true);
  3883. }
  3884. catch (IException *E)
  3885. {
  3886. StringBuffer msg;
  3887. result.append(E->errorMessage(msg));
  3888. E->Release();
  3889. }
  3890. __lenResult = result.length();
  3891. __result = result.detach();
  3892. }
  3893. } // namespace
  3894. // Callbacks from java
  3895. extern "C" {
  3896. JNIEXPORT jboolean JNICALL Java_com_HPCCSystems_HpccUtils__1hasNext (JNIEnv *, jclass, jlong);
  3897. JNIEXPORT jobject JNICALL Java_com_HPCCSystems_HpccUtils__1next (JNIEnv *, jclass, jlong);
  3898. JNIEXPORT jclass JNICALL Java_com_HPCCSystems_HpccClassLoader_defineClassForEmbed(JNIEnv *env, jobject loader, jint bytecodeLen, jlong bytecode, jstring name);
  3899. }
  3900. JNIEXPORT jboolean JNICALL Java_com_HPCCSystems_HpccUtils__1hasNext (JNIEnv *JNIenv, jclass, jlong proxy)
  3901. {
  3902. try
  3903. {
  3904. javaembed::ECLDatasetIterator *e = (javaembed::ECLDatasetIterator *) proxy;
  3905. return e->hasNext();
  3906. }
  3907. catch (IException *E)
  3908. {
  3909. StringBuffer msg;
  3910. E->errorMessage(msg);
  3911. E->Release();
  3912. jclass eClass = JNIenv->FindClass("java/lang/IllegalArgumentException");
  3913. if (eClass)
  3914. JNIenv->ThrowNew(eClass, msg.str());
  3915. return false;
  3916. }
  3917. }
  3918. JNIEXPORT jobject JNICALL Java_com_HPCCSystems_HpccUtils__1next (JNIEnv *JNIenv, jclass, jlong proxy)
  3919. {
  3920. try
  3921. {
  3922. javaembed::ECLDatasetIterator *e = (javaembed::ECLDatasetIterator *) proxy;
  3923. return e->next();
  3924. }
  3925. catch (IException *E)
  3926. {
  3927. StringBuffer msg;
  3928. E->errorMessage(msg);
  3929. E->Release();
  3930. jclass eClass = JNIenv->FindClass("java/lang/IllegalArgumentException");
  3931. if (eClass)
  3932. JNIenv->ThrowNew(eClass, msg.str());
  3933. return NULL;
  3934. }
  3935. }
  3936. JNIEXPORT jclass JNICALL Java_com_HPCCSystems_HpccClassLoader_defineClassForEmbed(JNIEnv *env, jobject loader, jint datalen, jlong data, jstring name)
  3937. {
  3938. const char *nameChars = env->GetStringUTFChars(name, nullptr);
  3939. size32_t namelen = strlen(nameChars);
  3940. MemoryBuffer b;
  3941. b.setBuffer(datalen, (void *) data, false);
  3942. b.setEndian(__BIG_ENDIAN);
  3943. jclass ret = nullptr;
  3944. while (b.remaining())
  3945. {
  3946. uint32_t siglen; b.read(siglen);
  3947. const char *sig = (const char *) b.readDirect(siglen);
  3948. uint32_t bytecodeLen; b.read(bytecodeLen);
  3949. const jbyte * bytecode = (const jbyte *) b.readDirect(bytecodeLen);
  3950. if (siglen >= namelen && memcmp(sig, nameChars, namelen)==0 && (namelen == siglen || sig[namelen] == '.'))
  3951. {
  3952. #ifdef TRACE_CLASSFILE
  3953. DBGLOG("javaembed: loading class %s (%.*s)", nameChars, siglen, sig);
  3954. #endif
  3955. ret = env->DefineClass(nameChars, loader, bytecode, bytecodeLen);
  3956. // NOTE - if there is an exception it will get thrown next time we get into java code
  3957. break;
  3958. }
  3959. }
  3960. if (!ret)
  3961. DBGLOG("javaembed: Failed to load class %s", nameChars);
  3962. env->ReleaseStringUTFChars(name, nameChars);
  3963. return ret;
  3964. }
  3965. // Used for dynamically loading in ESDL
  3966. extern "C" DECL_EXPORT IEmbedContext *getEmbedContextDynamic()
  3967. {
  3968. return javaembed::getEmbedContext();
  3969. }