java/demo/book/evictor_filesystem/Parser.java

   1 // **********************************************************************
   2 //
   3 // Copyright (c) 2003-2011 ZeroC, Inc. All rights reserved.
   4 //
   5 // This copy of Ice is licensed to you under the terms described in the
   6 // ICE_LICENSE file included in this distribution.
   7 //
   8 // **********************************************************************
   9
  10 import Filesystem.*;
  11
  12 class Parser
  13 {
  14     Parser(DirectoryPrx root)
  15     {
  16         _dirs = new java.util.LinkedList<DirectoryPrx>();
  17         _dirs.addFirst(root);
  18     }
  19
  20     void
  21     usage()
  22     {
  23         System.err.print(
  24             "help                    Print this message.\n" +
  25             "pwd                     Print current directory (/ = root).\n" +
  26             "cd [DIR]                Change directory (/ or empty = root).\n" +
  27             "ls                      List current directory.\n" +
  28             "lr                      Recursively list current directory.\n" +
  29             "mkdir DIR [DIR...]      Create directories DIR in current directory.\n" +
  30             "mkfile FILE [FILE...]   Create files FILE in current directory.\n" +
  31             "rm NAME [NAME...]       Delete directory or file NAME (rm * to delete all).\n" +
  32             "cat FILE                List the contents of FILE.\n" +
  33             "write FILE [STRING...]  Write STRING to FILE.\n" +
  34             "exit, quit              Exit this program.\n");
  35     }
  36
  37     void
  38     list(boolean recursive)
  39     {
  40         try
  41         {
  42             list(_dirs.get(0), recursive, 0);
  43         }
  44         catch(Ice.LocalException ex)
  45         {
  46             error(ex.toString());
  47         }
  48     }
  49
  50     void
  51     list(Filesystem.DirectoryPrx dir, boolean recursive, int depth)
  52     {
  53         StringBuilder b = new StringBuilder();
  54         for(int i = 0; i < depth; ++i)
  55         {
  56             b.append('\t');
  57         }
  58         String indent = b.toString();
  59
  60         NodeDesc[] contents = dir.list();
  61
  62         for(int i = 0; i < contents.length; ++i)
  63         {
  64             DirectoryPrx d
  65                 = contents[i].type == NodeType.DirType
  66                     ? DirectoryPrxHelper.uncheckedCast(contents[i].proxy)
  67                     : null;
  68             System.out.print(indent + contents[i].name + (d != null ? " (directory)" : " (file)"));
  69             if(d != null && recursive)
  70             {
  71                 System.out.println(":");
  72                 list(d, true, ++depth);
  73             }
  74             else
  75             {
  76                 System.out.println();
  77             }
  78         }
  79     }
  80
  81     void
  82     createFile(java.util.List<String> names)
  83     {
  84         DirectoryPrx dir = _dirs.getFirst();
  85
  86         for(String name : names)
  87         {
  88             if(name.equals(".."))
  89             {
  90                 System.out.println("Cannot create a file named `..'");
  91                 continue;
  92             }
  93
  94             try
  95             {
  96                 dir.createFile(name);
  97             }
  98             catch(NameInUse ex)
  99             {
 100                 System.out.println("`" + name + "' exists already");
 101             }
 102         }
 103     }
 104
 105     void
 106     createDir(java.util.List<String> names)
 107     {
 108         DirectoryPrx dir = _dirs.getFirst();
 109
 110         for(String name : names)
 111         {
 112             if(name.equals(".."))
 113             {
 114                 System.out.println("Cannot create a directory named `..'");
 115                 continue;
 116             }
 117
 118             try
 119             {
 120                 dir.createDirectory(name);
 121             }
 122             catch(NameInUse ex)
 123             {
 124                 System.out.println("`" + name + "' exists already");
 125             }
 126         }
 127     }
 128
 129     void
 130     pwd()
 131     {
 132         if(_dirs.size() == 1)
 133         {
 134             System.out.print("/");
 135         }
 136         else
 137         {
 138             java.util.ListIterator<DirectoryPrx> i = _dirs.listIterator(_dirs.size());
 139             i.previous();
 140             while(i.hasPrevious())
 141             {
 142                 System.out.print("/" + i.previous().name());
 143             }
 144         }
 145         System.out.println();
 146     }
 147
 148     void
 149     cd(String name)
 150     {
 151         if(name.equals("/"))
 152         {
 153             while(_dirs.size() > 1)
 154             {
 155                 _dirs.removeFirst();
 156             }
 157             return;
 158         }
 159
 160         if(name.equals(".."))
 161         {
 162             if(_dirs.size() > 1)
 163             {
 164                 _dirs.removeFirst();
 165             }
 166             return;
 167         }
 168
 169         DirectoryPrx dir = _dirs.getFirst();
 170         NodeDesc d;
 171         try
 172         {
 173             d = dir.find(name);
 174         }
 175         catch(NoSuchName ex)
 176         {
 177             System.out.println("`" + name + "': no such directory");
 178             return;
 179         }
 180         if(d.type == NodeType.FileType)
 181         {
 182             System.out.println("`" + name + "': not a directory");
 183             return;
 184         }
 185         _dirs.addFirst(DirectoryPrxHelper.uncheckedCast(d.proxy));
 186     }
 187
 188     void
 189     cat(String name)
 190     {
 191         DirectoryPrx dir = _dirs.getFirst();
 192         NodeDesc d;
 193         try
 194         {
 195             d = dir.find(name);
 196         }
 197         catch(NoSuchName ex)
 198         {
 199             System.out.println("`" + name + "': no such file");
 200             return;
 201         }
 202         if(d.type == NodeType.DirType)
 203         {
 204             System.out.println("`" + name + "': not a file");
 205             return;
 206         }
 207         FilePrx f = FilePrxHelper.uncheckedCast(d.proxy);
 208         String[] l = f.read();
 209         for(int i = 0; i < l.length; ++i)
 210         {
 211             System.out.println(l[i]);
 212         }
 213     }
 214
 215     void
 216     write(java.util.LinkedList<String> args)
 217     {
 218         DirectoryPrx dir = _dirs.getFirst();
 219         String name = args.getFirst();
 220         args.removeFirst();
 221         NodeDesc d;
 222         try
 223         {
 224             d = dir.find(name);
 225         }
 226         catch(NoSuchName ex)
 227         {
 228             System.out.println("`" + name + "': no such file");
 229             return;
 230         }
 231         if(d.type == NodeType.DirType)
 232         {
 233             System.out.println("`" + name + "': not a file");
 234             return;
 235         }
 236         FilePrx f = FilePrxHelper.uncheckedCast(d.proxy);
 237
 238         String[] l = args.toArray(new String[0]);
 239         try
 240         {
 241             f.write(l);
 242         }
 243         catch(GenericError ex)
 244         {
 245             System.out.println("`" + name + "': cannot write to file: " + ex.reason);
 246         }
 247     }
 248
 249     void
 250     destroy(java.util.List<String> names)
 251     {
 252         DirectoryPrx dir = _dirs.getFirst();
 253
 254         for(String name : names)
 255         {
 256             if(name.equals("*"))
 257             {
 258                 NodeDesc[] nodes = dir.list();
 259                 for(NodeDesc node : nodes)
 260                 {
 261                     try
 262                     {
 263                         node.proxy.destroy();
 264                     }
 265                     catch(PermissionDenied ex)
 266                     {
 267                         System.out.println("cannot remove `" + node.name + "': " + ex.reason);
 268                     }
 269                 }
 270                 return;
 271             }
 272             else
 273             {
 274                 NodeDesc d;
 275                 try
 276                 {
 277                     d = dir.find(name);
 278                 }
 279                 catch(NoSuchName ex)
 280                 {
 281                     System.out.println("`" + name + "': no such file or directory");
 282                     return;
 283                 }
 284                 try
 285                 {
 286                     d.proxy.destroy();
 287                 }
 288                 catch(PermissionDenied ex)
 289                 {
 290                     System.out.println("cannot remove `" + name + "': " + ex.reason);
 291                 }
 292             }
 293         }
 294     }
 295
 296     void
 297     error(String s)
 298     {
 299         System.err.println("error: " + s);
 300     }
 301
 302     void
 303     warning(String s)
 304     {
 305         System.err.println("warning: " + s);
 306     }
 307
 308     String
 309     getInput()
 310     {
 311         System.out.print("> ");
 312         System.out.flush();
 313
 314         try
 315         {
 316             return _in.readLine();
 317         }
 318         catch(java.io.IOException e)
 319         {
 320             return null;
 321         }
 322     }
 323
 324     int
 325     parse()
 326     {
 327         _in = new java.io.BufferedReader(new java.io.InputStreamReader(System.in));
 328
 329         Grammar g = new Grammar(this);
 330         g.parse();
 331
 332         return 0;
 333     }
 334
 335     int
 336     parse(java.io.BufferedReader in)
 337     {
 338         _in = in;
 339
 340         Grammar g = new Grammar(this);
 341         g.parse();
 342
 343         return 0;
 344     }
 345
 346     private java.util.LinkedList<DirectoryPrx> _dirs;
 347
 348     private java.io.BufferedReader _in;
 349 }