src/dom/work/Idlp.java

   1 import java.io.*;
   2 import java.util.*;
   3
   4
   5 public class Idlp
   6 {
   7 String parsebuf;
   8 int len;
   9
  10
  11 void error(String msg)
  12 {
  13     System.out.println("Idlp err : " + msg);
  14 }
  15
  16 void trace(String msg)
  17 {
  18     System.out.println("Idlp : " + msg);
  19 }
  20
  21
  22
  23
  24
  25
  26 int get(int pos)
  27 {
  28     if (pos<0 || pos>=len)
  29         return -1;
  30     else
  31         return (int) parsebuf.charAt(pos);
  32 }
  33
  34
  35 int skipwhite(int pos)
  36 {
  37     trace("skipwhite()");
  38     while (pos < len)
  39         {
  40         int ch = get(pos);
  41         if (ch == '/' && get(pos + 1) == '/')
  42             {
  43             pos += 2;
  44             while (pos < len)
  45                 {
  46                 ch = get(pos);
  47                 if (ch == '\n' || ch == '\r')
  48                     break;
  49                 pos++;
  50                 }
  51             }
  52         else if (!Character.isWhitespace(ch))
  53             {
  54             break;
  55             }
  56         pos++;
  57         }
  58     return pos;
  59 }
  60
  61 boolean match(String key)
  62 {
  63     trace("match(" + key + ")");
  64     int p = 0;
  65     for (int i=0 ; i<key.length() ; i++)
  66         {
  67         if (get(p) != key.charAt(i))
  68             return false;
  69         p++;
  70         }
  71     return true;
  72
  73 }
  74
  75 String word = "";
  76
  77 int getword(int pos)
  78 {
  79     trace("getword()");
  80     StringBuffer buf = new StringBuffer();
  81     while (pos < len)
  82         {
  83         int ch = get(pos);
  84         if (ch < 0)
  85             break;
  86         if (!Character.isLetterOrDigit(ch) && ch != '#' && ch != '_')
  87             break;
  88         buf.append((char)ch);
  89         pos++;
  90         }
  91     word = buf.toString();
  92     return pos;
  93 }
  94
  95 int getDirective(String name, int pos)
  96 {
  97     trace("getDirective()");
  98     if (name.length() == 0 || name.charAt(0) != '#')
  99         return -1;
 100     while (pos < len)
 101         {
 102         int ch = get(pos);
 103         if (ch == '\n' || ch == '\r')
 104             break;
 105         pos++;
 106         }
 107     return pos;
 108 }
 109
 110 int getTypedef(int pos)
 111 {
 112     trace("getTypedef()");
 113     while (pos < len)
 114         {
 115         int ch = get(pos++);
 116         if (ch == ';')
 117             break;
 118         }
 119     return pos;
 120 }
 121
 122
 123 int getInterface(int pos)
 124 {
 125     trace("getInterface()");
 126     pos = skipwhite(pos);
 127     int p = getword(pos);
 128     if (p < 0)
 129         return -1;
 130     if (p <= pos)
 131         {
 132         error("expected interface name");
 133         return -1;
 134         }
 135     String intfName = word;
 136     trace("intf: " + intfName);
 137     pos = p;
 138     pos = skipwhite(pos);
 139     int ch = get(pos);
 140     if (ch == ';')
 141         {
 142         pos++; //forward decl
 143         trace("forward decl");
 144         return pos;
 145         }
 146     if (ch != '{')
 147         {
 148         error("Expected opening { for interface");
 149         return -1;
 150         }
 151     pos++;
 152     while (true)
 153         {
 154         pos = skipwhite(pos);
 155         ch = get(pos);
 156         if (ch == '}')
 157             {
 158             break;
 159             }
 160         p = getword(pos);
 161         if (p < 0)
 162             {
 163             return -1;
 164             }
 165         if (p<=pos)
 166             {
 167             error("expected word");
 168             return -1;
 169             }
 170         trace("word : " + word);
 171         if (word.equals("typedef"))
 172             {
 173             pos = p;
 174             p = getTypedef(pos);
 175             if (p < 0)
 176                 return -1;
 177             }
 178         pos = p;
 179         }
 180
 181     return pos;
 182 }
 183
 184
 185 int getException(int pos)
 186 {
 187     trace("getException()");
 188     pos = skipwhite(pos);
 189     int p = getword(pos);
 190     if (p < 0)
 191         return -1;
 192     if (p <= pos)
 193         {
 194         error("expected exception name");
 195         return -1;
 196         }
 197     String exName = word;
 198     trace("ex: " + exName);
 199     pos = p;
 200     pos = skipwhite(pos);
 201     int ch = get(pos);
 202     if (ch == ';')
 203         {
 204         pos++; //forward decl
 205         trace("forward decl");
 206         return pos;
 207         }
 208     if (ch != '{')
 209         {
 210         error("Expected opening { for exception");
 211         return -1;
 212         }
 213     pos++;
 214     while (pos < len)
 215         {
 216         ch = get(pos++);
 217         if (ch == '}')
 218             {
 219             break;
 220             }
 221         }
 222     pos = skipwhite(pos);
 223     ch = get(pos);
 224     if (ch != ';')
 225         {
 226         error("expected ; for exception");
 227         return -1;
 228         }
 229     pos++;
 230     return pos;
 231 }
 232
 233
 234
 235 int getModule(int pos)
 236 {
 237     trace("getModule()");
 238     pos = skipwhite(pos);
 239     int p = getword(pos);
 240     if (p < 0)
 241         return -1;
 242     if (p <= pos)
 243         {
 244         error("expected module name");
 245         return -1;
 246         }
 247     String modName = word;
 248     trace("mod: " + modName);
 249     pos = p;
 250     pos = skipwhite(pos);
 251     int ch = get(pos);
 252     if (ch != '{')
 253         {
 254         error("Expected opening { for module");
 255         return -1;
 256         }
 257     pos++;
 258     while (true)
 259         {
 260         pos = skipwhite(pos);
 261         ch = get(pos);
 262         if (ch == '}')
 263             {
 264             break;
 265             }
 266         p = getword(pos);
 267         if (p < 0)
 268             {
 269             return -1;
 270             }
 271         if (p<=pos)
 272             {
 273             error("expected word");
 274             return -1;
 275             }
 276         trace("word : " + word);
 277         if (word.equals("typedef"))
 278             {
 279             pos = p;
 280             p = getTypedef(pos);
 281             if (p < 0)
 282                 return -1;
 283             }
 284         else if (word.equals("interface"))
 285             {
 286             pos = p;
 287             p = getInterface(pos);
 288             if (p < 0)
 289                 return -1;
 290             }
 291         else if (word.equals("exception"))
 292             {
 293             pos = p;
 294             p = getException(pos);
 295             if (p < 0)
 296                 return -1;
 297             }
 298         else if (word.equals("module"))
 299             {
 300             pos = p;
 301             p = getModule(pos);
 302             if (p < 0)
 303                 return -1;
 304             }
 305         pos = p;
 306         }
 307
 308     return pos;
 309 }
 310
 311 boolean parse()
 312 {
 313     trace("parse()");
 314     len = parsebuf.length();
 315     int pos = 0;
 316     while (pos < len)
 317         {
 318         pos = skipwhite(pos);
 319         if (pos >= len)
 320             break;
 321         int ch = get(pos);
 322         int p = getword(pos);
 323         if (p < 0)
 324             return false;
 325         if (p<=pos)
 326             {
 327             error("expected word");
 328             return false;
 329             }
 330         trace("word: " + word);
 331         if (word.length() == 0)
 332             break;
 333         if (word.charAt(0) == '#')
 334             {
 335             p = getDirective(word, pos);
 336             if (p < 0)
 337                 return false;
 338             }
 339         else if (word.equals("module"))
 340             {
 341             pos = p;
 342             p = getModule(pos);
 343             if (p<0)
 344                 return false;
 345             }
 346         pos = p;
 347         }
 348
 349     return true;
 350 }
 351
 352
 353 boolean run()
 354 {
 355     parsebuf = "";
 356     boolean ret = true;
 357     try
 358         {
 359         StringBuffer inbuf = new StringBuffer();
 360         FileReader in = new FileReader("svg.idl");
 361         while (true)
 362             {
 363             int ch = in.read();
 364             if (ch < 0)
 365                 break;
 366             inbuf.append((char)ch);
 367             }
 368         in.close();
 369         parsebuf = inbuf.toString();
 370         ret = parse();
 371         }
 372     catch (IOException e)
 373         {
 374         error("run : " + e);
 375         return false;
 376         }
 377     return ret;
 378 }
 379
 380
 381 public Idlp()
 382 {
 383 }
 384
 385
 386 public static void main(String argv[])
 387 {
 388     Idlp idlp = new Idlp();
 389     idlp.run();
 390 }
 391
 392
 393
 394 }