wrap/utils/DefReader.d

   1 /*
   2  * This file is part of duit.
   3  *
   4  * duit is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU Lesser General Public License as published by
   6  * the Free Software Foundation; either version 2.1 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * duit is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public License
  15  * along with duit; if not, write to the Free Software
  16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  17  */
  18
  19 module utils.DefReader;
  20
  21
  22 //debug=file;
  23
  24 /**
  25  * Reads and processes the API defintion file
  26  * Stores global values:
  27  * - license text
  28  * -
  29  */
  30 public class DefReader
  31 {
  32
  33         private import std.file;
  34         private import std.string;
  35
  36         private import std.stdio;
  37
  38         private import utils.DuitClass;
  39
  40         char[] fileName;
  41         char[][] lines;
  42
  43         char[] fullLine;
  44         char[] key;
  45         char[] value;
  46
  47         int currLine = 0;
  48
  49         /**
  50          * Creates a new DegReader.
  51          * Reads the entire definition file
  52          * Params:
  53          *      fileName =      The file name of the file containing the conversion definition
  54          */
  55         this ( char[] fileName )
  56         {
  57                 this.fileName = fileName;
  58                 debug(file)writefln("DefReader.ctor fileName = %s", fileName);
  59                 lines = std.string.splitlines(cast(char[]) std.file.read(fileName));
  60         }
  61
  62         public char[] toString()
  63         {
  64                 char[] str;
  65                 str ~= "\n[DefReader]"
  66                                 ~ "\nfileName = "~fileName
  67                                 ~ "\ncurrLine = "~std.string.toString(currLine)
  68                                 ~ "\nfullLine = "~fullLine
  69                                 ~ "\nkey      = "~key
  70                                 ~ "\nvalue    + "~value
  71                                 ;
  72                 return str;
  73         }
  74
  75         char[] getFileName()
  76         {
  77                 return fileName;
  78         }
  79
  80         /**
  81          * Gets the next key/value pair.
  82          * both key and value a stripped of non visible start and ending chars
  83          * Returns: The key after read the next key/value pair
  84          */
  85         char[] next(bit skipEmpty = true)
  86         {
  87                 key.length = 0;
  88                 value.length = 0;
  89                 char[] line;
  90                 if ( currLine < lines.length )
  91                 {
  92                         fullLine = lines[currLine++];
  93                         line = std.string.strip(fullLine.dup);
  94                         int commentCount = 0;
  95                         while ( skipEmpty
  96                                         && (commentCount > 0  || line.length ==0 || line[0] == '#' || DuitClass.startsWith(line, "#*") )
  97                                         && currLine < lines.length
  98                                         )
  99                         {
 100                                 if ( DuitClass.startsWith(line, "#*") )
 101                                 {
 102                                         ++commentCount;
 103                                 }
 104                                 else if ( DuitClass.startsWith(line, "*#") )
 105                                 {
 106                                         --commentCount;
 107                                 }
 108
 109                                 fullLine = lines[currLine++];
 110                                 line = std.string.strip(fullLine.dup);
 111                         }
 112                 }
 113
 114                 if ( line.length > 0 )
 115                 {
 116                         int pos = std.string.find(line, ':');
 117                         if ( pos > 0 )
 118                         {
 119                                 key = std.string.strip(line[0 .. pos]);
 120                                 value = std.string.strip(line[pos+1 .. line.length]);
 121                         }
 122                 }
 123                 else
 124                 {
 125                         key.length = 0;
 126                         value.length = 0;
 127                 }
 128
 129                 //writefln("key=%s value=%s",key,value);
 130
 131                 return key;
 132         }
 133
 134         /**
 135          * Gets the key of the current key/value pair
 136          * Returns: The current key
 137          */
 138         char[] getKey()
 139         {
 140                 return key;
 141         }
 142
 143         /**
 144          * Gets the value of the current key/value pair
 145          * Returns: The current value
 146          */
 147         char[] getValue()
 148         {
 149                 return value;
 150         }
 151
 152
 153         bit getValueBit()
 154         {
 155                 return std.string.find(" 1 ok OK Ok true TRUE True Y y yes YES Yes ", value) > 0;
 156         }
 157
 158         char[] getFullLine()
 159         {
 160                 return fullLine;
 161         }
 162         /**
 163          * Gets the current line number
 164          * Returns: The current line number
 165          */
 166         int getLineNumber()
 167         {
 168                 return currLine;
 169         }
 170
 171 }