rtl/java/Files.java

   1 import java.io.*;
   2 import java.util.*;
   3
   4 class Files
   5 {
   6         /* File / Handle */
   7         public static class RECORD0
   8         {
   9                 File path;
  10                 File regpath;
  11                 RandomAccessFile desc;
  12
  13                 public static void $COPY$(RECORD0 dst, RECORD0 src)
  14                 {
  15                         dst.path    = src.path;
  16                         dst.regpath = src.regpath;
  17                         dst.desc    = src.desc;
  18                 }
  19
  20                 void SetActive(RECORD1 rider)
  21                         throws
  22                                 IOException
  23                 {
  24                         desc.seek(rider.position);
  25                 }
  26         }
  27
  28         /* Rider */
  29         public static class RECORD1
  30         {
  31                 long position;
  32                 RECORD0 base;
  33                 public boolean[] eof = new boolean[1];
  34                 public int[] res = new int[1];
  35
  36                 public static void $COPY$(RECORD1 dst, RECORD1 src)
  37                 {
  38                         dst.base     = src.base;
  39                         dst.position = src.position;
  40                         dst.eof[0]   = src.eof[0];
  41                         dst.res[0]   = src.res[0];
  42                 }
  43         }
  44
  45         public static RECORD0 Old(byte name[])
  46         {
  47                 File filepath;
  48                 RandomAccessFile filedesc;
  49                 RECORD0 file;
  50
  51                 filepath = new File(SYSTEM.STRING(name));
  52
  53                 if(!filepath.exists() || !filepath.isFile())
  54                 {
  55                         return null;
  56                 }
  57
  58                 try
  59                 {
  60                         filedesc = new RandomAccessFile(filepath, "rw");
  61                 }
  62                 catch(IOException e)
  63                 {
  64                         try
  65                         {
  66                                 filedesc = new RandomAccessFile(filepath, "r");
  67                         }
  68                         catch(IOException g)
  69                         {
  70                                 return null;
  71                         }
  72                 }
  73
  74                 file = new RECORD0();
  75                 file.path = filepath;
  76                 file.regpath = filepath;
  77                 file.desc = filedesc;
  78                 return file;
  79         }
  80
  81         private static String RandomString(int len)
  82         {
  83                 Random x = new Random();
  84                 String s = new String();
  85                 for(int i = 0; i < len; i++)
  86                 {
  87                         s += (char) (x.nextInt(25) + 65);
  88                 }
  89                 return s;
  90         }
  91
  92         public static RECORD0 New(byte name[])
  93         {
  94                 RandomAccessFile filedesc;
  95                 File filepath;
  96                 File fileregpath;
  97                 String filename;
  98                 RECORD0 file;
  99
 100                 try
 101                 {
 102                         filepath = File.createTempFile(SYSTEM.STRING(name), "tmp");
 103                         fileregpath = new File(SYSTEM.STRING(name));
 104                         filedesc = new RandomAccessFile(filepath, "rw");
 105                 }
 106                 catch(IOException e)
 107                 {
 108                         return null;
 109                 }
 110
 111                 file = new RECORD0();
 112                 file.path = filepath;
 113                 file.regpath = fileregpath.getAbsoluteFile();
 114                 file.desc = filedesc;
 115                 return file;
 116         }
 117
 118         public static void Register(RECORD0 f)
 119                 throws
 120                         IOException
 121         {
 122                 java.nio.file.Files.move(
 123                         java.nio.file.Paths.get(f.path.getPath()),
 124                         java.nio.file.Paths.get(f.regpath.getPath()),
 125                         java.nio.file.StandardCopyOption.REPLACE_EXISTING
 126                 );
 127                 f.path = f.regpath;
 128         }
 129
 130         public static void Close(RECORD0 f)
 131         {
 132         }
 133
 134         public static void Purge(RECORD0 f)
 135                 throws
 136                         IOException
 137         {
 138                 f.desc.setLength(0);
 139         }
 140
 141         public static void Delete(byte name[], short res[], int res$)
 142         {
 143                 File filepath = new File(SYSTEM.STRING(name));
 144                 res[res$] = (short) (filepath.delete() ? (0) : (1));
 145         }
 146
 147         public static void Rename(byte old[], byte _new[], short res[], int res$)
 148         {
 149                 File oldpath = new File(SYSTEM.STRING(old));
 150                 File newpath = new File(SYSTEM.STRING(_new));
 151                 res[res$] = (short) (oldpath.renameTo(newpath) ? (0) : (1));
 152         }
 153
 154         public static int Length(RECORD0 f)
 155                 throws
 156                         IOException
 157         {
 158                 return (int) f.desc.length();
 159         }
 160
 161         public static void GetDate(RECORD0 f, int t[], int t$, int d[], int d$)
 162         {
 163                 long time = f.path.lastModified();
 164                 Calendar cal = Calendar.getInstance();
 165                 cal.setTimeInMillis(time);
 166                 t[t$] = cal.get(Calendar.HOUR_OF_DAY) * 4096 + cal.get(Calendar.MINUTE) * 64 + cal.get(Calendar.SECOND);
 167                 d[d$] = cal.get(Calendar.YEAR) * 512 + cal.get(Calendar.MONTH) * 32 + cal.get(Calendar.DAY_OF_WEEK);
 168         }
 169
 170         public static void Set(RECORD1 r[], int r$, RECORD0 f, int pos)
 171         {
 172                 RECORD1 rider = r[r$];
 173                 rider.base = f;
 174                 rider.position = pos;
 175                 rider.res[0] = 0;
 176                 rider.eof[0] = false;
 177         }
 178
 179         public static int Pos(RECORD1 r[], int r$)
 180         {
 181                 return (int) r[r$].position;
 182         }
 183
 184         public static RECORD0 Base(RECORD1 r[], int r$)
 185         {
 186                 return r[r$].base;
 187         }
 188
 189         public static void Read(RECORD1 r[], int r$, byte x[], int x$)
 190         {
 191                 RECORD1 rider = r[r$];
 192                 RandomAccessFile desc = rider.base.desc;
 193
 194                 try
 195                 {
 196                         rider.base.SetActive(rider);
 197                         x[x$] = (byte) desc.read();
 198                         rider.position += 1;
 199                 }
 200                 catch(IOException e)
 201                 {
 202                         rider.res[0] = 1;
 203                         rider.eof[0] = true;
 204                 }
 205         }
 206
 207         public static void ReadInt(RECORD1 R[], int R$, short x[], int x$)
 208         {
 209                 RECORD1 rider = R[R$];
 210                 RandomAccessFile desc = rider.base.desc;
 211
 212                 try
 213                 {
 214                         rider.base.SetActive(rider);
 215                         byte[] buf = new byte[2];
 216                         rider.res[0] = desc.read(buf, 0, 2);
 217                         rider.eof[0] = (rider.res[0] != 0);
 218                         x[x$] = (short) (((buf[1] & 0xff) << 8) | (buf[0] & 0xff));
 219                         rider.position += 2 - rider.res[0];
 220                 }
 221                 catch(IOException e)
 222                 {
 223                         rider.res[0] = 2;
 224                         rider.eof[0] = true;
 225                 }
 226         }
 227
 228         public static void ReadLInt(RECORD1 R[], int R$, int x[], int x$)
 229         {
 230                 RECORD1 rider = R[R$];
 231                 RandomAccessFile desc = rider.base.desc;
 232
 233                 try
 234                 {
 235                         rider.base.SetActive(rider);
 236                         byte[] buf = new byte[4];
 237                         rider.res[0] = desc.read(buf, 0, 4);
 238                         rider.eof[0] = (rider.res[0] != 0);
 239                         x[x$] = ((buf[3] & 0xff) << 24) | ((buf[2] & 0xff) << 16) | ((buf[1] & 0xff) << 8) | (buf[0] & 0xff);
 240                         rider.position += 4 - rider.res[0];
 241                 }
 242                 catch(IOException e)
 243                 {
 244                         rider.res[0] = 4;
 245                         rider.eof[0] = true;
 246                 }
 247         }
 248
 249         public static void ReadReal(RECORD1 R[], int R$, float x[], int x$)
 250         {
 251                 RECORD1 rider = R[R$];
 252                 RandomAccessFile desc = rider.base.desc;
 253
 254                 try
 255                 {
 256                         rider.base.SetActive(rider);
 257                         x[x$] = desc.readFloat();
 258                         rider.position += 4;
 259                 }
 260                 catch(IOException e)
 261                 {
 262                         rider.res[0] = 4;
 263                         rider.eof[0] = true;
 264                 }
 265         }
 266
 267         public static void ReadLReal(RECORD1 R[], int R$, double x[], int x$)
 268         {
 269                 RECORD1 rider = R[R$];
 270                 RandomAccessFile desc = rider.base.desc;
 271
 272                 try
 273                 {
 274                         rider.base.SetActive(rider);
 275                         x[x$] = desc.readDouble();
 276                         rider.position += 8;
 277                 }
 278                 catch(IOException e)
 279                 {
 280                         rider.res[0] = 8;
 281                         rider.eof[0] = true;
 282                 }
 283         }
 284
 285         public static void ReadNum(RECORD1 R[], int R$, int x[], int x$)
 286         {
 287                 SYSTEM.TRAP(-3);
 288         }
 289
 290         public static void ReadString(RECORD1 R[], int R$, byte x[][], int x$)
 291         {
 292                 RECORD1 rider = R[R$];
 293                 RandomAccessFile desc = rider.base.desc;
 294
 295                 int i = 0;
 296                 try
 297                 {
 298                         rider.base.SetActive(rider);
 299                         int ch;
 300                         do {
 301                                 ch = x[x$][i] = (byte) desc.read();
 302                                 i += 1;
 303                         } while(ch != 0);
 304                         rider.position += i;
 305                 }
 306                 catch(IOException e)
 307                 {
 308                         x[x$][i] = 0;
 309                         rider.res[0] = 1;
 310                         rider.eof[0] = true;
 311                 }
 312         }
 313
 314         public static void ReadSet(RECORD1 R[], int R$, int x[], int x$)
 315         {
 316                 ReadLInt(R, R$, x, x$);
 317         }
 318
 319         public static void ReadBool(RECORD1 R[], int R$, boolean x[], int x$)
 320         {
 321                 RECORD1 rider = R[R$];
 322                 RandomAccessFile desc = rider.base.desc;
 323
 324                 try
 325                 {
 326                         rider.base.SetActive(rider);
 327                         int i = desc.read();
 328                         x[x$] = (i != 0);
 329                         rider.position += 1;
 330                 }
 331                 catch(IOException e)
 332                 {
 333                         rider.res[0] = 1;
 334                         rider.eof[0] = true;
 335                 }
 336         }
 337
 338         public static void ReadBytes(RECORD1 r[], int r$, byte x[][], int x$, int n)
 339         {
 340                 RECORD1 rider = r[r$];
 341                 RandomAccessFile desc = rider.base.desc;
 342
 343                 try
 344                 {
 345                         rider.base.SetActive(rider);
 346                         rider.res[0] = desc.read(x[x$], 0, n);
 347                         rider.eof[0] = (rider.res[0] != 0);
 348                         rider.position += n - rider.res[0];
 349                 }
 350                 catch(IOException e)
 351                 {
 352                         e.printStackTrace();
 353                         rider.res[0] = n;
 354                         rider.eof[0] = true;
 355                 }
 356         }
 357
 358         public static void Write(RECORD1 r[], int r$, byte x)
 359         {
 360                 RECORD1 rider = r[r$];
 361                 RandomAccessFile desc = rider.base.desc;
 362
 363                 try
 364                 {
 365                         rider.base.SetActive(rider);
 366                         desc.write(x);
 367                         rider.position += 1;
 368                 }
 369                 catch(IOException e)
 370                 {
 371                         rider.res[0] = 1;
 372                         rider.eof[0] = true;
 373                 }
 374         }
 375
 376         public static void WriteInt(RECORD1 R[], int R$, short x)
 377         {
 378                 SYSTEM.TRAP(-3);
 379         }
 380
 381         public static void WriteLInt(RECORD1 R[], int R$, int x)
 382         {
 383                 SYSTEM.TRAP(-3);
 384         }
 385
 386         public static void WriteReal(RECORD1 R[], int R$, float x)
 387         {
 388                 SYSTEM.TRAP(-3);
 389         }
 390
 391         public static void WriteLReal(RECORD1 R[], int R$, double x)
 392         {
 393                 SYSTEM.TRAP(-3);
 394         }
 395
 396         public static void WriteNum(RECORD1 R[], int R$, int x)
 397         {
 398                 SYSTEM.TRAP(-3);
 399         }
 400
 401         public static void WriteString(RECORD1 R[], int R$, byte x[])
 402         {
 403                 SYSTEM.TRAP(-3);
 404         }
 405
 406         public static void WriteSet(RECORD1 R[], int R$, int x)
 407         {
 408                 SYSTEM.TRAP(-3);
 409         }
 410
 411         public static void WriteBool(RECORD1 R[], int R$, boolean x)
 412         {
 413                 SYSTEM.TRAP(-3);
 414         }
 415
 416         public static void WriteBytes(RECORD1 r[], int r$, byte[][] x, int x$, int n)
 417         {
 418                 SYSTEM.TRAP(-3);
 419         }
 420
 421         public static void BEGIN()
 422         {
 423
 424         }
 425 }