1 /*
  2  * Copyright (c) 2025, Oracle and/or its affiliates. All rights reserved.
  3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  4  *
  5  * This code is free software; you can redistribute it and/or modify it
  6  * under the terms of the GNU General Public License version 2 only, as
  7  * published by the Free Software Foundation.
  8  *
  9  * This code is distributed in the hope that it will be useful, but WITHOUT
 10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 12  * version 2 for more details (a copy is included in the LICENSE file that
 13  * accompanied this code).
 14  *
 15  * You should have received a copy of the GNU General Public License version
 16  * 2 along with this work; if not, write to the Free Software Foundation,
 17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 18  *
 19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 20  * or visit www.oracle.com if you need additional information or have any
 21  * questions.
 22  */
 23 
 24 final class InvokableLeafOps {
 25 
 26     public static String add(String a, String b) {
 27         return a.concat(b);
 28     }
 29 
 30 
 31     public static boolean eq(Object a, Object b) {
 32         return a == b;
 33     }
 34 
 35     public static boolean neq(Object a, Object b) {
 36         return a != b;
 37     }
 38 
 39 
 40     public static boolean not(boolean l) {
 41         return !l;
 42     }
 43 
 44     // int
 45 
 46     public static int neg(int l) {
 47         return -l;
 48     }
 49 
 50     public static int compl(int l) {
 51         return ~l;
 52     }
 53 
 54     public static int add(int l, int r) {
 55         return l + r;
 56     }
 57 
 58     public static int sub(int l, int r) {
 59         return l - r;
 60     }
 61 
 62     public static int mul(int l, int r) {
 63         return l * r;
 64     }
 65 
 66     public static int div(int l, int r) {
 67         return l / r;
 68     }
 69 
 70     public static int mod(int l, int r) {
 71         return l % r;
 72     }
 73 
 74     public static int or(int l, int r) {
 75         return l | r;
 76     }
 77 
 78     public static int and(int l, int r) {
 79         return l & r;
 80     }
 81 
 82     public static int xor(int l, int r) {
 83         return l ^ r;
 84     }
 85 
 86     public static int lshl(int l, int r) {
 87         return l << r;
 88     }
 89 
 90     public static int ashr(int l, int r) {
 91         return l >> r;
 92     }
 93 
 94     public static int lshr(int l, int r) {
 95         return l >>> r;
 96     }
 97 
 98     public static int lshl(int l, long r) {
 99         return l << r;
100     }
101 
102     public static int ashr(int l, long r) {
103         return l >> r;
104     }
105 
106     public static int lshr(int l, long r) {
107         return l >>> r;
108     }
109 
110     public static boolean eq(int l, int r) {
111         return l == r;
112     }
113 
114     public static boolean neq(int l, int r) {
115         return l != r;
116     }
117 
118     public static boolean gt(int l, int r) {
119         return l > r;
120     }
121 
122     public static boolean ge(int l, int r) {
123         return l >= r;
124     }
125 
126     public static boolean lt(int l, int r) {
127         return l < r;
128     }
129 
130     public static boolean le(int l, int r) {
131         return l <= r;
132     }
133 
134     // byte
135 
136     public static byte neg(byte l) {
137         return (byte) -l;
138     }
139 
140     public static byte compl(byte l) {
141         return (byte) ~l;
142     }
143 
144     public static byte add(byte l, byte r) {
145         return (byte) (l + r);
146     }
147 
148     public static byte sub(byte l, byte r) {
149         return (byte) (l - r);
150     }
151 
152     public static byte mul(byte l, byte r) {
153         return (byte) (l * r);
154     }
155 
156     public static byte div(byte l, byte r) {
157         return (byte) (l / r);
158     }
159 
160     public static byte mod(byte l, byte r) {
161         return (byte) (l % r);
162     }
163 
164     public static byte or(byte l, byte r) {
165         return (byte) (l | r);
166     }
167 
168     public static byte and(byte l, byte r) {
169         return (byte) (l & r);
170     }
171 
172     public static byte xor(byte l, byte r) {
173         return (byte) (l ^ r);
174     }
175 
176     public static byte ashr(byte l, long r) {
177         return (byte) (l >> r);
178     }
179 
180     public static byte lshr(byte l, long r) {
181         return (byte) (l >>> r);
182     }
183 
184     public static byte lshl(byte l, int r) {
185         return (byte) (l << r);
186     }
187 
188     public static byte ashr(byte l, int r) {
189         return (byte) (l >> r);
190     }
191 
192     public static byte lshr(byte l, int r) {
193         return (byte) (l >>> r);
194     }
195 
196     public static boolean eq(byte l, byte r) {
197         return l == r;
198     }
199 
200     public static boolean neq(byte l, byte r) {
201         return l != r;
202     }
203 
204     public static boolean gt(byte l, byte r) {
205         return l > r;
206     }
207 
208     public static boolean ge(byte l, byte r) {
209         return l >= r;
210     }
211 
212     public static boolean lt(byte l, byte r) {
213         return l < r;
214     }
215 
216     public static boolean le(byte l, byte r) {
217         return l <= r;
218     }
219 
220     // short
221 
222     public static short neg(short l) {
223         return (short) -l;
224     }
225 
226     public static short compl(short l) {
227         return (short) ~l;
228     }
229 
230     public static short add(short l, short r) {
231         return (short) (l + r);
232     }
233 
234     public static short sub(short l, short r) {
235         return (short) (l - r);
236     }
237 
238     public static short mul(short l, short r) {
239         return (short) (l * r);
240     }
241 
242     public static short div(short l, short r) {
243         return (short) (l / r);
244     }
245 
246     public static short mod(short l, short r) {
247         return (short) (l % r);
248     }
249 
250     public static short or(short l, short r) {
251         return (short) (l | r);
252     }
253 
254     public static short and(short l, short r) {
255         return (short) (l & r);
256     }
257 
258     public static short xor(short l, short r) {
259         return (short) (l ^ r);
260     }
261 
262     public static short ashr(short l, long r) {
263         return (short) (l >> r);
264     }
265 
266     public static short lshr(short l, long r) {
267         return (short) (l >>> r);
268     }
269 
270     public static short lshl(short l, int r) {
271         return (short) (l << r);
272     }
273 
274     public static short ashr(short l, int r) {
275         return (short) (l >> r);
276     }
277 
278     public static short lshr(short l, int r) {
279         return (short) (l >>> r);
280     }
281 
282     public static boolean eq(short l, short r) {
283         return l == r;
284     }
285 
286     public static boolean neq(short l, short r) {
287         return l != r;
288     }
289 
290     public static boolean gt(short l, short r) {
291         return l > r;
292     }
293 
294     public static boolean ge(short l, short r) {
295         return l >= r;
296     }
297 
298     public static boolean lt(short l, short r) {
299         return l < r;
300     }
301 
302     public static boolean le(short l, short r) {
303         return l <= r;
304     }
305 
306     // char
307 
308     public static char neg(char l) {
309         return (char) -l;
310     }
311 
312     public static char compl(char l) {
313         return (char) ~l;
314     }
315 
316     public static char add(char l, char r) {
317         return (char) (l + r);
318     }
319 
320     public static char sub(char l, char r) {
321         return (char) (l - r);
322     }
323 
324     public static char mul(char l, char r) {
325         return (char) (l * r);
326     }
327 
328     public static char div(char l, char r) {
329         return (char) (l / r);
330     }
331 
332     public static char mod(char l, char r) {
333         return (char) (l % r);
334     }
335 
336     public static char or(char l, char r) {
337         return (char) (l | r);
338     }
339 
340     public static char and(char l, char r) {
341         return (char) (l & r);
342     }
343 
344     public static char xor(char l, char r) {
345         return (char) (l ^ r);
346     }
347 
348     public static char ashr(char l, long r) {
349         return (char) (l >> r);
350     }
351 
352     public static char lshr(char l, long r) {
353         return (char) (l >>> r);
354     }
355 
356     public static char lshl(char l, int r) {
357         return (char) (l << r);
358     }
359 
360     public static char ashr(char l, int r) {
361         return (char) (l >> r);
362     }
363 
364     public static char lshr(char l, int r) {
365         return (char) (l >>> r);
366     }
367 
368     public static boolean eq(char l, char r) {
369         return l == r;
370     }
371 
372     public static boolean neq(char l, char r) {
373         return l != r;
374     }
375 
376     public static boolean gt(char l, char r) {
377         return l > r;
378     }
379 
380     public static boolean ge(char l, char r) {
381         return l >= r;
382     }
383 
384     public static boolean lt(char l, char r) {
385         return l < r;
386     }
387 
388     public static boolean le(char l, char r) {
389         return l <= r;
390     }
391     // long
392 
393     public static long neg(long l) {
394         return -l;
395     }
396 
397     public static long compl(long l) {
398         return ~l;
399     }
400 
401     public static long add(long l, long r) {
402         return l + r;
403     }
404 
405     public static long sub(long l, long r) {
406         return l - r;
407     }
408 
409     public static long mul(long l, long r) {
410         return l * r;
411     }
412 
413     public static long div(long l, long r) {
414         return l / r;
415     }
416 
417     public static long mod(long l, long r) {
418         return l % r;
419     }
420 
421     public static long or(long l, long r) {
422         return l | r;
423     }
424 
425     public static long and(long l, long r) {
426         return l & r;
427     }
428 
429     public static long xor(long l, long r) {
430         return l ^ r;
431     }
432 
433     public static long lshl(long l, long r) {
434         return l << r;
435     }
436 
437     public static long ashr(long l, long r) {
438         return l >> r;
439     }
440 
441     public static long lshr(long l, long r) {
442         return l >>> r;
443     }
444 
445     public static long lshl(long l, int r) {
446         return l << r;
447     }
448 
449     public static long ashr(long l, int r) {
450         return l >> r;
451     }
452 
453     public static long lshr(long l, int r) {
454         return l >>> r;
455     }
456 
457     public static boolean eq(long l, long r) {
458         return l == r;
459     }
460 
461     public static boolean neq(long l, long r) {
462         return l != r;
463     }
464 
465     public static boolean gt(long l, long r) {
466         return l > r;
467     }
468 
469     public static boolean ge(long l, long r) {
470         return l >= r;
471     }
472 
473     public static boolean lt(long l, long r) {
474         return l < r;
475     }
476 
477     public static boolean le(long l, long r) {
478         return l <= r;
479     }
480 
481 
482     // float
483 
484     static float neg(float l) {
485         return -l;
486     }
487 
488     static float add(float l, float r) {
489         return l + r;
490     }
491 
492     static float sub(float l, float r) {
493         return l - r;
494     }
495 
496     static float mul(float l, float r) {
497         return l * r;
498     }
499 
500     static float div(float l, float r) {
501         return l / r;
502     }
503 
504     static float mod(float l, float r) {
505         return l % r;
506     }
507 
508     public static boolean eq(float l, float r) {
509         return l == r;
510     }
511 
512     public static boolean neq(float l, float r) {
513         return l != r;
514     }
515 
516     public static boolean gt(float l, float r) {
517         return l > r;
518     }
519 
520     public static boolean ge(float l, float r) {
521         return l >= r;
522     }
523 
524     public static boolean lt(float l, float r) {
525         return l < r;
526     }
527 
528     public static boolean le(float l, float r) {
529         return l <= r;
530     }
531 
532 
533     // double
534 
535     static double neg(double l) {
536         return -l;
537     }
538 
539     static double add(double l, double r) {
540         return l + r;
541     }
542 
543     static double sub(double l, double r) {
544         return l - r;
545     }
546 
547     static double mul(double l, double r) {
548         return l * r;
549     }
550 
551     static double div(double l, double r) {
552         return l / r;
553     }
554 
555     static double mod(double l, double r) {
556         return l % r;
557     }
558 
559     public static boolean eq(double l, double r) {
560         return l == r;
561     }
562 
563     public static boolean neq(double l, double r) {
564         return l != r;
565     }
566 
567     public static boolean gt(double l, double r) {
568         return l > r;
569     }
570 
571     public static boolean ge(double l, double r) {
572         return l >= r;
573     }
574 
575     public static boolean lt(double l, double r) {
576         return l < r;
577     }
578 
579     public static boolean le(double l, double r) {
580         return l <= r;
581     }
582 
583 
584     // boolean
585 
586     static boolean eq(boolean l, boolean r) {
587         return l == r;
588     }
589 
590     static boolean neq(boolean l, boolean r) {
591         return l != r;
592     }
593 
594     static boolean and(boolean l, boolean r) {
595         return l & r;
596     }
597 
598     static boolean or(boolean l, boolean r) {
599         return l | r;
600     }
601 
602     static boolean xor(boolean l, boolean r) {
603         return l ^ r;
604     }
605 
606 
607     // Primitive conversions
608 
609     // double conversion
610     static double conv_double(double i) {
611         return i;
612     }
613 
614     static float conv_float(double i) {
615         return (float) i;
616     }
617 
618     static long conv_long(double i) {
619         return (long) i;
620     }
621 
622     static int conv_int(double i) {
623         return (int) i;
624     }
625 
626     static short conv_short(double i) {
627         return (short) i;
628     }
629 
630     static char conv_char(double i) {
631         return (char) i;
632     }
633 
634     static byte conv_byte(double i) {
635         return (byte) i;
636     }
637 
638     static boolean conv_boolean(double i) {
639         return ((int) i & 1) == 1;
640     }
641 
642     // float conversion
643     static double conv_double(float i) {
644         return i;
645     }
646 
647     static float conv_float(float i) {
648         return i;
649     }
650 
651     static long conv_long(float i) {
652         return (long) i;
653     }
654 
655     static int conv_int(float i) {
656         return (int) i;
657     }
658 
659     static short conv_short(float i) {
660         return (short) i;
661     }
662 
663     static char conv_char(float i) {
664         return (char) i;
665     }
666 
667     static byte conv_byte(float i) {
668         return (byte) i;
669     }
670 
671     static boolean conv_boolean(float i) {
672         return ((int) i & 1) == 1;
673     }
674 
675     // long conversion
676     static double conv_double(long i) {
677         return (double) i;
678     }
679 
680     static float conv_float(long i) {
681         return (float) i;
682     }
683 
684     static long conv_long(long i) {
685         return i;
686     }
687 
688     static int conv_int(long i) {
689         return (int) i;
690     }
691 
692     static short conv_short(long i) {
693         return (short) i;
694     }
695 
696     static char conv_char(long i) {
697         return (char) i;
698     }
699 
700     static byte conv_byte(long i) {
701         return (byte) i;
702     }
703 
704     static boolean conv_boolean(long i) {
705         return (i & 1) == 1;
706     }
707 
708     // int conversion
709     static double conv_double(int i) {
710         return (double) i;
711     }
712 
713     static float conv_float(int i) {
714         return (float) i;
715     }
716 
717     static long conv_long(int i) {
718         return i;
719     }
720 
721     static int conv_int(int i) {
722         return i;
723     }
724 
725     static short conv_short(int i) {
726         return (short) i;
727     }
728 
729     static char conv_char(int i) {
730         return (char) i;
731     }
732 
733     static byte conv_byte(int i) {
734         return (byte) i;
735     }
736 
737     static boolean conv_boolean(int i) {
738         return (i & 1) == 1;
739     }
740 
741     // short conversion
742     static double conv_double(short i) {
743         return i;
744     }
745 
746     static float conv_float(short i) {
747         return i;
748     }
749 
750     static long conv_long(short i) {
751         return i;
752     }
753 
754     static int conv_int(short i) {
755         return i;
756     }
757 
758     static short conv_short(short i) {
759         return i;
760     }
761 
762     static char conv_char(short i) {
763         return (char) i;
764     }
765 
766     static byte conv_byte(short i) {
767         return (byte) i;
768     }
769 
770     static boolean conv_boolean(short i) {
771         return (i & 1) == 1;
772     }
773 
774     // char conversion
775     static double conv_double(char i) {
776         return i;
777     }
778 
779     static float conv_float(char i) {
780         return i;
781     }
782 
783     static long conv_long(char i) {
784         return i;
785     }
786 
787     static int conv_int(char i) {
788         return i;
789     }
790 
791     static short conv_short(char i) {
792         return (short) i;
793     }
794 
795     static char conv_char(char i) {
796         return i;
797     }
798 
799     static byte conv_byte(char i) {
800         return (byte) i;
801     }
802 
803     static boolean conv_boolean(char i) {
804         return (i & 1) == 1;
805     }
806 
807     // byte conversion
808     static double conv_double(byte i) {
809         return i;
810     }
811 
812     static float conv_float(byte i) {
813         return i;
814     }
815 
816     static long conv_long(byte i) {
817         return i;
818     }
819 
820     static int conv_int(byte i) {
821         return i;
822     }
823 
824     static short conv_short(byte i) {
825         return i;
826     }
827 
828     static char conv_char(byte i) {
829         return (char) i;
830     }
831 
832     static byte conv_byte(byte i) {
833         return i;
834     }
835 
836     static boolean conv_boolean(byte i) {
837         return (i & 1) == 1;
838     }
839 
840     // boolean conversion
841     static double conv_double(boolean i) {
842         return i ? 1d : 0d;
843     }
844 
845     static float conv_float(boolean i) {
846         return i ? 1f : 0f;
847     }
848 
849     static long conv_long(boolean i) {
850         return i ? 1l : 0l;
851     }
852 
853     static int conv_int(boolean i) {
854         return i ? 1 : 0;
855     }
856 
857     static short conv_short(boolean i) {
858         return i ? (short) 1 : 0;
859     }
860 
861     static char conv_char(boolean i) {
862         return i ? (char) 1 : 0;
863     }
864 
865     static byte conv_byte(boolean i) {
866         return i ? (byte) 1 : 0;
867     }
868 
869     static boolean conv_boolean(boolean i) {
870         return i;
871     }
872 }