Updated for openjdk-19-internal
[panamaz] / src / template / Frame.java
1 /*
2  * Copyright (C) 2021 Michael Zucchi
3  *
4  * This program is free software: you can redistribute it and/or modify
5  * it under the terms of the GNU General Public License as published by
6  * the Free Software Foundation, either version 3 of the License, or
7  * (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
16  */
17 package api;
18
19 import jdk.incubator.foreign.*;
20 import static jdk.incubator.foreign.ValueLayout.OfAddress;
21
22 public interface Frame extends AutoCloseable, SegmentAllocator {
23
24         @Override
25         MemorySegment allocate(long size, long alignment);
26
27         @Override
28         public void close();
29
30         default MemorySegment allocateInt() {
31                 return allocate(Memory.INT);
32         }
33
34         default MemorySegment allocateInt(int count) {
35                 return allocate(Memory.INT, count);
36         }
37
38         default MemorySegment allocateLong() {
39                 return allocate(Memory.LONG);
40         }
41
42         default MemorySegment allocateLong(int count) {
43                 return allocateArray(Memory.LONG, count);
44         }
45
46         default MemorySegment allocatePointer() {
47                 return allocate(Memory.POINTER);
48         }
49
50         default MemorySegment allocatePointer(int count) {
51                 return allocateArray(Memory.POINTER, count);
52         }
53
54         default MemorySegment allocateArray(OfAddress type, MemoryAddress[] value) {
55                 MemorySegment m = allocateArray(type, value.length);
56                 for (int i=0;i<value.length;i++)
57                         m.setAtIndex(type, i, value[i]);
58                 return m;
59         }
60
61         default MemorySegment copy(byte value) {
62                 return allocate(Memory.BYTE, value);
63         }
64
65         default MemorySegment copy(short value) {
66                 return allocate(Memory.SHORT, value);
67         }
68
69         default MemorySegment copy(int value) {
70                 return allocate(Memory.INT, value);
71         }
72
73         default MemorySegment copy(long value) {
74                 return allocate(Memory.LONG, value);
75         }
76
77         default MemorySegment copy(float value) {
78                 return allocate(Memory.FLOAT, value);
79         }
80
81         default MemorySegment copy(double value) {
82                 return allocate(Memory.DOUBLE, value);
83         }
84
85         default MemorySegment copy(byte[] value) {
86                 return allocateArray(Memory.BYTE, value);
87         }
88
89         default MemorySegment copy(int[] value) {
90                 return allocateArray(Memory.INT, value);
91         }
92
93         default MemorySegment copy(long[] value) {
94                 return allocateArray(Memory.LONG, value);
95         }
96
97         default MemorySegment copy(float[] value) {
98                 return allocateArray(Memory.FLOAT, value);
99         }
100
101         default public MemorySegment copy(String value) {
102                 return allocateUtf8String(value);
103         }
104
105         /*
106         default <T extends Native> MemorySegment copy(T[] array) {
107                 MemorySegment mem = allocateAddress(array.length);
108                 for (int i = 0; i < array.length; i++)
109                         MemoryAccess.setAddressAtIndex(mem, i, array[i].address());
110                 return mem;
111         }
112
113         default <T extends Native> MemorySegment copy(T value) {
114                 return copy(value.address());
115         }
116
117         default <T extends Native> MemorySegment copy(MemoryAddress value) {
118                 MemorySegment mem = allocateAddress();
119                 MemoryAccess.setAddress(mem, value);
120                 return mem;
121         }
122          */
123         // create an array pointing to strings
124         default MemorySegment copy(String[] array) {
125                 if (array != null) {
126                         MemorySegment list = allocatePointer(array.length);
127                         for (int i = 0; i < array.length; i++) {
128                                 list.setAtIndex(Memory.POINTER, i, copy(array[i]));
129                         }
130                         return list;
131                 } else {
132                         return Memory.NULL;
133                 }
134         }
135
136 }