java/demo/book/map_filesystem/Grammar.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 class Grammar
  11 {
  12     Grammar(Parser p)
  13     {
  14         _parser = p;
  15         _scanner = new Scanner(_parser);
  16     }
  17
  18     void
  19     parse()
  20     {
  21         while(true)
  22         {
  23             try
  24             {
  25                 _token = _scanner.nextToken();
  26                 if(_token == null)
  27                 {
  28                     return;
  29                 }
  30                 else if(_token.type == Token.TOK_SEMI)
  31                 {
  32                     // Continue
  33                 }
  34                 else if(_token.type == Token.TOK_HELP)
  35                 {
  36                     _token = _scanner.nextToken();
  37                     if(_token.type != Token.TOK_SEMI)
  38                     {
  39                         throw new ParseError("Expected ';'");
  40                     }
  41                     _parser.usage();
  42                 }
  43                 else if(_token.type == Token.TOK_EXIT)
  44                 {
  45                     _token = _scanner.nextToken();
  46                     if(_token.type != Token.TOK_SEMI)
  47                     {
  48                         throw new ParseError("Expected ';'");
  49                     }
  50                     return;
  51                 }
  52                 else if(_token.type == Token.TOK_LIST)
  53                 {
  54                     _token = _scanner.nextToken();
  55                     if(_token.type != Token.TOK_SEMI)
  56                     {
  57                         throw new ParseError("Expected ';'");
  58                     }
  59                     _parser.list(false);
  60                 }
  61                 else if(_token.type == Token.TOK_LIST_RECURSIVE)
  62                 {
  63                     _token = _scanner.nextToken();
  64                     if(_token.type != Token.TOK_SEMI)
  65                     {
  66                         throw new ParseError("Expected ';'");
  67                     }
  68                     _parser.list(true);
  69                 }
  70                 else if(_token.type == Token.TOK_CREATE_FILE)
  71                 {
  72                     java.util.List<String> s = strings();
  73                     if(_token.type != Token.TOK_SEMI)
  74                     {
  75                         throw new ParseError("Expected ';'");
  76                     }
  77                     if(s.size() == 0)
  78                     {
  79                         throw new ParseError("usage: mkfile FILE [FILE...]");
  80                     }
  81                     _parser.createFile(s);
  82                 }
  83                 else if(_token.type == Token.TOK_CREATE_DIR)
  84                 {
  85                     java.util.List<String> s = strings();
  86                     if(_token.type != Token.TOK_SEMI)
  87                     {
  88                         throw new ParseError("Expected ';'");
  89                     }
  90                     if(s.size() == 0)
  91                     {
  92                         throw new ParseError("usage: mkdir DIR [DIR...]");
  93                     }
  94                     _parser.createDir(s);
  95                 }
  96                 else if(_token.type == Token.TOK_PWD)
  97                 {
  98                     _token = _scanner.nextToken();
  99                     if(_token.type != Token.TOK_SEMI)
 100                     {
 101                         throw new ParseError("Expected ';'");
 102                     }
 103                     _parser.pwd();
 104                 }
 105                 else if(_token.type == Token.TOK_CD)
 106                 {
 107                     java.util.List<String> s = strings();
 108                     if(_token.type != Token.TOK_SEMI)
 109                     {
 110                         throw new ParseError("Expected ';'");
 111                     }
 112                     if(s.size() > 1)
 113                     {
 114                         throw new ParseError("usage: cd [DIR]");
 115                     }
 116                     else if(s.size() == 0)
 117                     {
 118                         _parser.cd("/");
 119                     }
 120                     else
 121                     {
 122                         _parser.cd((String)s.get(0));
 123                     }
 124                 }
 125                 else if(_token.type == Token.TOK_CAT)
 126                 {
 127                     java.util.List<String> s = strings();
 128                     if(_token.type != Token.TOK_SEMI)
 129                     {
 130                         throw new ParseError("Expected ';'");
 131                     }
 132                     if(s.size() != 1)
 133                     {
 134                         throw new ParseError("usage: cat FILE");
 135                     }
 136                     _parser.cat((String)s.get(0));
 137                 }
 138                 else if(_token.type == Token.TOK_WRITE)
 139                 {
 140                     java.util.LinkedList<String> s = strings();
 141                     if(_token.type != Token.TOK_SEMI)
 142                     {
 143                         throw new ParseError("Expected ';'");
 144                     }
 145                     if(s.size() == 0)
 146                     {
 147                         throw new ParseError("usage: write FILE [STRING...]");
 148                     }
 149                     _parser.write(s);
 150                 }
 151                 else if(_token.type == Token.TOK_RM)
 152                 {
 153                     java.util.List<String> s = strings();
 154                     if(_token.type != Token.TOK_SEMI)
 155                     {
 156                         throw new ParseError("Expected ';'");
 157                     }
 158                     if(s.size() == 0)
 159                     {
 160                         throw new ParseError("usage: rm NAME [NAME...]");
 161                     }
 162                     _parser.destroy(s);
 163                 }
 164                 else
 165                 {
 166                     _parser.error("parse error");
 167                 }
 168             }
 169             catch(ParseError e)
 170             {
 171                 _parser.error("Parse error: " + e.getMessage());
 172             }
 173         }
 174     }
 175
 176     private java.util.LinkedList<String>
 177     strings()
 178     {
 179         java.util.LinkedList<String> l = new java.util.LinkedList<String>();
 180         while(true)
 181         {
 182             _token = _scanner.nextToken();
 183             if(_token.type != Token.TOK_STRING)
 184             {
 185                 return l;
 186             }
 187             l.add(_token.value);
 188         }
 189     }
 190
 191     static private class ParseError extends RuntimeException
 192     {
 193         ParseError(String msg)
 194         {
 195             super(msg);
 196         }
 197     }
 198
 199     private Parser _parser;
 200     private Scanner _scanner;
 201     private Token _token;
 202 }