emulators/springcoat-vm/src/main/java/cc/squirreljme/vm/springcoat/MLENativeArchive.java

   1 // -*- Mode: Java; indent-tabs-mode: t; tab-width: 4 -*-
   2 // ---------------------------------------------------------------------------
   3 // Multi-Phasic Applications: SquirrelJME
   4 //     Copyright (C) Stephanie Gawroriski <xer@multiphasicapps.net>
   5 // ---------------------------------------------------------------------------
   6 // SquirrelJME is under the Mozilla Public License Version 2.0.
   7 // See license.mkd for licensing and copyright information.
   8 // ---------------------------------------------------------------------------
   9
  10 package cc.squirreljme.vm.springcoat;
  11
  12 import cc.squirreljme.jvm.mle.NativeArchiveShelf;
  13 import cc.squirreljme.jvm.mle.brackets.NativeArchiveBracket;
  14 import cc.squirreljme.jvm.mle.brackets.NativeArchiveEntryBracket;
  15 import cc.squirreljme.jvm.mle.exceptions.MLECallError;
  16 import cc.squirreljme.vm.springcoat.brackets.NativeArchiveEntryObject;
  17 import cc.squirreljme.vm.springcoat.brackets.NativeArchiveObject;
  18 import cc.squirreljme.vm.springcoat.exceptions.SpringMLECallError;
  19 import java.io.IOException;
  20
  21 /**
  22  * SpringCoat layer for {@link NativeArchiveShelf}.
  23  *
  24  * @since 2024/03/05
  25  */
  26 public enum MLENativeArchive
  27         implements MLEFunction
  28 {
  29         /** {@link NativeArchiveShelf#archiveClose(NativeArchiveBracket)}. */
  30         ARCHIVE_CLOSE("archiveClose:" +
  31                 "(Lcc/squirreljme/jvm/mle/brackets/NativeArchiveBracket;)V")
  32         {
  33                 /**
  34                  * {@inheritDoc}
  35                  * @since 2024/03/05
  36                  */
  37                 @Override
  38                 public Object handle(SpringThreadWorker __thread, Object... __args)
  39                 {
  40                         Object archive = __args[0];
  41
  42                         try
  43                         {
  44                                 NativeArchiveShelf.archiveClose(
  45                                         MLENativeArchive.__archiveObject(archive).wrapped);
  46                         }
  47                         catch (MLECallError __e)
  48                         {
  49                                 throw new SpringMLECallError(__e);
  50                         }
  51
  52                         return null;
  53                 }
  54         },
  55
  56         /**
  57          * {@link NativeArchiveShelf#archiveEntry(NativeArchiveBracket,
  58          * String)}.
  59          */
  60         ARCHIVE_ENTRY("archiveEntry:" +
  61                 "(Lcc/squirreljme/jvm/mle/brackets/NativeArchiveBracket;" +
  62                 "Ljava/lang/String)" +
  63                 "Lcc/squirreljme/jvm/mle/brackets/NativeArchiveEntryBracket;")
  64         {
  65                 /**
  66                  * {@inheritDoc}
  67                  * @since 2024/03/05
  68                  */
  69                 @Override
  70                 public Object handle(SpringThreadWorker __thread, Object... __args)
  71                 {
  72                         Object archive = __args[0];
  73                         String name = __thread.asNativeObject(String.class, __args[1]);
  74
  75                         try
  76                         {
  77                                 NativeArchiveEntryBracket entry =
  78                                         NativeArchiveShelf.archiveEntry(
  79                                                 MLENativeArchive.__archiveObject(archive).wrapped,
  80                                                 name);
  81                                 if (entry == null)
  82                                         return SpringNullObject.NULL;
  83
  84                                 return new NativeArchiveEntryObject(__thread.machine,
  85                                         entry);
  86                         }
  87                         catch (MLECallError __e)
  88                         {
  89                                 throw new SpringMLECallError(__e);
  90                         }
  91                 }
  92         },
  93
  94         /** {@link NativeArchiveShelf#archiveOpenZip(byte[], int, int)}. */
  95         ARCHIVE_OPEN_ZIP("archiveOpenZip:" +
  96                 "([BII)Lcc/squirreljme/jvm/mle/brackets/NativeArchiveBracket;")
  97         {
  98                 /**
  99                  * {@inheritDoc}
 100                  * @since 2024/03/05
 101                  */
 102                 @Override
 103                 public Object handle(SpringThreadWorker __thread, Object... __args)
 104                 {
 105                         SpringArrayObjectByte buf = (SpringArrayObjectByte)__args[0];
 106                         int off = (Integer)__args[1];
 107                         int len = (Integer)__args[2];
 108
 109                         try
 110                         {
 111                                 return new NativeArchiveObject(__thread.machine,
 112                                         NativeArchiveShelf.archiveOpenZip(buf.array(),
 113                                                 off, len));
 114                         }
 115                         catch (MLECallError __e)
 116                         {
 117                                 throw new SpringMLECallError(__e);
 118                         }
 119                 }
 120         },
 121
 122         /**
 123          * {@link NativeArchiveShelf#entryIsDirectory(NativeArchiveEntryBracket)}.
 124          */
 125         ENTRY_IS_DIRECTORY("entryIsDirectory:" +
 126                 "(Lcc/squirreljme/jvm/mle/brackets/NativeArchiveEntryBracket;)Z")
 127         {
 128                 /**
 129                  * {@inheritDoc}
 130                  * @since 2024/03/05
 131                  */
 132                 @Override
 133                 public Object handle(SpringThreadWorker __thread, Object... __args)
 134                 {
 135                         NativeArchiveEntryObject entry =
 136                                 MLENativeArchive.__entryObject(__args[0]);
 137
 138                         try
 139                         {
 140                                 return NativeArchiveShelf.entryIsDirectory(entry.wrapped);
 141                         }
 142                         catch (MLECallError __e)
 143                         {
 144                                 throw new SpringMLECallError(__e);
 145                         }
 146                 }
 147         },
 148
 149         /** {@link NativeArchiveShelf#entryOpen(NativeArchiveEntryBracket)}. */
 150         ENTRY_OPEN("entryOpen:" +
 151                 "(Lcc/squirreljme/jvm/mle/brackets/NativeArchiveEntryBracket;)" +
 152                 "Ljava/io/InputStream;")
 153         {
 154                 /**
 155                  * {@inheritDoc}
 156                  * @since 2024/03/05
 157                  */
 158                 @Override
 159                 public Object handle(SpringThreadWorker __thread, Object... __args)
 160                 {
 161                         NativeArchiveEntryObject entry =
 162                                 MLENativeArchive.__entryObject(__args[0]);
 163
 164                         try
 165                         {
 166                                 return __thread.proxyInputStream(
 167                                         NativeArchiveShelf.entryOpen(entry.wrapped));
 168                         }
 169                         catch (MLECallError|IOException __e)
 170                         {
 171                                 throw new SpringMLECallError(__e);
 172                         }
 173                 }
 174         },
 175
 176         /**
 177          * {@link NativeArchiveShelf#entryUncompressedSize(
 178          * NativeArchiveEntryBracket)}.
 179          */
 180         ENTRY_UNCOMPRESSED_SIZE("entryUncompressedSize:" +
 181                 "(Lcc/squirreljme/jvm/mle/brackets/NativeArchiveEntryBracket;)J")
 182         {
 183                 /**
 184                  * {@inheritDoc}
 185                  * @since 2024/03/05
 186                  */
 187                 @Override
 188                 public Object handle(SpringThreadWorker __thread, Object... __args)
 189                 {
 190                         NativeArchiveEntryObject entry =
 191                                 MLENativeArchive.__entryObject(__args[0]);
 192
 193                         try
 194                         {
 195                                 return NativeArchiveShelf.entryUncompressedSize(entry.wrapped);
 196                         }
 197                         catch (MLECallError __e)
 198                         {
 199                                 throw new SpringMLECallError(__e);
 200                         }
 201                 }
 202         },
 203
 204         /** End. */
 205         ;
 206
 207         /** The dispatch key. */
 208         protected final String key;
 209
 210         /**
 211          * Initializes the dispatcher info.
 212          *
 213          * @param __key The key.
 214          * @throws NullPointerException On null arguments.
 215          * @since 2024/03/05
 216          */
 217         MLENativeArchive(String __key)
 218                 throws NullPointerException
 219         {
 220                 if (__key == null)
 221                         throw new NullPointerException("NARG");
 222
 223                 this.key = __key;
 224         }
 225
 226         /**
 227          * {@inheritDoc}
 228          * @since 2024/03/05
 229          */
 230         @Override
 231         public String key()
 232         {
 233                 return this.key;
 234         }
 235
 236         /**
 237          * Checks if this is a {@link NativeArchiveObject}.
 238          *
 239          * @param __object The object to check.
 240          * @return As one if this is one.
 241          * @throws SpringMLECallError If this is not one.
 242          * @since 2024/03/05
 243          */
 244         static NativeArchiveObject __archiveObject(Object __object)
 245                 throws SpringMLECallError
 246         {
 247                 if (!(__object instanceof NativeArchiveObject))
 248                         throw new SpringMLECallError("Not a NativeArchiveObject.");
 249
 250                 return (NativeArchiveObject)__object;
 251         }
 252
 253         /**
 254          * Checks if this is a {@link NativeArchiveEntryObject}.
 255          *
 256          * @param __object The object to check.
 257          * @return As one if this is one.
 258          * @throws SpringMLECallError If this is not one.
 259          * @since 2024/03/05
 260          */
 261         static NativeArchiveEntryObject __entryObject(Object __object)
 262                 throws SpringMLECallError
 263         {
 264                 if (!(__object instanceof NativeArchiveEntryObject))
 265                         throw new SpringMLECallError(
 266                                 "Not a NativeArchiveEntryObject.");
 267
 268                 return (NativeArchiveEntryObject)__object;
 269         }
 270 }