JEtherPix

1) /* JFlexiPix - Java implementation of FlexiPix output library
2)  *
3)  * Copyright 2010-2011 Stefan Schuermans <stefan blinkenarea org>
4)  *
5)  * This program is free software: you can redistribute it and/or modify
6)  * it under the terms of the GNU General Public License as published by
7)  * the Free Software Foundation, version 3 of the License.
8)  *
9)  *
10)  * This program is distributed in the hope that it will be useful,
11)  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12)  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13)  * GNU General Public License for more details.
14)  *
15)  * You should have received a copy of the GNU Lesser General Public License
16)  * along with this program. If not, see <http://www.gnu.org/licenses/>.
17)  */
18) 
19) package org.blinkenarea.JFlexiPix;
20) 
21) import java.io.*;

22) import java.net.*;

23) import java.util.*;
24) import java.util.regex.*;
25) 
26) /// configuration parser
27) class Config
28) {
29)   /**
30)    * @brief constructor
31)    * @param[in] display display to configure
32)    * @param[in] messageIf message interface to report messages to or null
33)    */
34)   Config(Display display, MessageIf messageIf)
35)   {
36)     // save constructor parameters
37)     m_display   = display;
38)     m_messageIf = messageIf;
39) 
40)     // compile regular expression patterns
41) 
42)     // empty lines: "   # comment"
43)     m_patternEmpty = Pattern.compile("^" + "\\s*" + "(?:#.*)?" + "$");
44) 
45)     // extract setting and value from "   setting   =   value   # comment"
46)     m_patternLine = Pattern.compile("^" +
47)                                     "\\s*" +
48)                                     "([^\\s=#](?:[^=#]*[^\\s=#])?)" +
49)                                     "\\s*=\\s*" +
50)                                     "([^\\s=#](?:[^=#]*[^\\s=#])?)" +
51)                                     "\\s*" + 
52)                                     "(?:#.*)?" +
53)                                     "$");
54)   }
55) 
56)   /**
57)    * @brief process distributor from config file
58)    *
59)    * @param[in] settingPart2 second half of setting to process
60)    * @param[in] value value of setting
61)    */
62)   void procDistri(String settingPart2, String value)
63)     throws Exception
64)   {

65)     int dist, out, pix;
66)     Pixel px;
67) 
68)     // get distributor number
69)     try {
70)       dist = Integer.parseInt(settingPart2);
71)     } catch (NumberFormatException e) {
72)       dist = Constants.distriMaxCnt; // force error in next line
73)     }
74)     if (dist >= Constants.distriMaxCnt)
75)       error("invalid distributor number \"" + settingPart2 +
76)             String.format(" in line %d of config file", m_lineNo));
77) 
78)     // get number of outputs and pixels
79)     px = PixelParser.parsePixel(value); // abuse for "outputs,pixels"
80)     if (px == null)
81)       error("invalid distributor size \"" + value +
82)             String.format(" in line %d of config file", m_lineNo));
83)     out = px.m_x;
84)     if (out >= Constants.outputMaxCnt)
85)       error(String.format("invalid number of outputs \"%d\"" +
86)                           " in line %d of config file", out, m_lineNo));
87)     pix = px.m_y;
88)     if (pix >= Constants.pixelMaxCnt)
89)       error(String.format("invalid number of pixels \"%d\"" +
90)                           " in line %d of config file", pix, m_lineNo));
91) 
92)     // check if distributor is already present
93)     if (m_display.m_distris[dist] != null)
94)       error(String.format("duplicate definition of distributor \"%d\"" +
95)                           " in line %d of config file", dist, m_lineNo));
96) 
97)     // create new distributor
98)     m_display.m_distris[dist] = new Distri(dist, out, pix);
99) 
100)     // count distributors
101)     ++m_display.m_distriCnt;

102)   }
103) 
104)   /**
105)    * @brief process mapping from config file
106)    *
107)    * @param[in] settingPart2 second half of setting to process
108)    * @param[in] value value of setting
109)    */
110)   void procMapping(String settingPart2, String value)
111)     throws Exception
112)   {
113)     // TODO
114)   }
115) 
116)   /**
117)    * @brief process pixel from config file
118)    *
119)    * @param[in] txtPixel text of pixel to process
120)    * @param[in] dist number of distributor
121)    * @param[in] out number of output
122)    * @param[in] pix number of pixel
123)    */
124)   void procPixel(String txtPixel, int dist, int out, int pix)
125)     throws Exception
126)   {
127)     // TODO
128)   }
129) 
130)   /**
131)    * @brief process output from config file
132)    *
133)    * @param[in] settingPart2 second half of setting to process
134)    * @param[in] value value of setting
135)    */
136)   void procOutput(String settingPart2, String value)
137)     throws Exception
138)   {
139)     // TODO
140)   }
141) 
142)   /**
143)    * @brief process setting from config file
144)    *
145)    * @param[in] setting setting to process
146)    * @param[in] value value of setting
147)    */
148)   void procSetting(String setting, String value)
149)     throws Exception
150)   {

151)     InetSocketAddress addr;
152)     Pixel pix;

153) 

154)     // replace all whitespace in setting with spaces
155)     setting = setting.replace('\t', ' ').replace('\r', ' ')
156)                      .replace('\n', ' ').replace('\f', ' ');
157) 
158)     // bind address of UDP output
159)     if (setting.equals("bindAddr")) {
160)       addr = AddrParser.parseAddr(value);
161)       if (addr == null) {
162)         error("invalid addess \"" + value + "\" for \"" + setting +
163)               String.format(" in line %d of config file", m_lineNo));
164)       }
165)       info("bind address: " + addr.toString());
166)       m_display.m_bindAddr = addr;
167)       return;
168)     }
169) 
170)     // size of display
171)     if (setting.equals("size")) {
172)       pix = PixelParser.parsePixel(value);
173)       if (pix == null || pix.m_x <= 0 || pix.m_y <= 0) {
174)         error("invalid value \"" + value + "\" for \"" + setting +
175)               String.format(" in line %d of config file", m_lineNo));
176)       }
177)       m_display.m_size = pix;
178)       return;
179)     }
180) 
181)     // distributor
182)     if (setting.startsWith("distributor ")) {
183)       procDistri(setting.substring(12), value);
184)       return;
185)     }
186) 
187)     // mapping
188)     if (setting.startsWith("mapping ")) {
189)       procMapping(setting.substring(8), value);
190)       return;
191)     }
192) 
193)     // distributor
194)     if (setting.startsWith("output ")) {
195)       procOutput(setting.substring(7), value);
196)       return;
197)     }
198) 
199)     // unknown setting
200)     warning("unknown setting \"" + setting +
201)             String.format(" in line %d of config file", m_lineNo) +
202)             ", ignored");

203)   }
204) 
205)   /**
206)    * @brief process line from config file
207)    *
208)    * @param[in] line line to process
209)    */
210)   void procLine(String line)
211)     throws Exception
212)   {
213)     Matcher matcher;
214)     String setting, value;
215) 
216)     // ignore empty lines: "   # comment"
217)     matcher = m_patternEmpty.matcher(line);
218)     if (matcher.find())
219)       return;
220) 
221)     // extract setting and value from "   setting   =   value   # comment"
222)     matcher = m_patternLine.matcher(line);
223)     if (!matcher.find()) {
224)       // line cannot be parsed
225)       if (m_messageIf != null)
226)         m_messageIf.message(MsgType.Warn,
227)                             String.format("invalid line %d in config file," +
228)                                           " ignored\n", m_lineNo));
229)       return;
230)     }
231)     setting = matcher.group(1);
232)     value   = matcher.group(2);
233) 
234)     // process setting
235)     procSetting(setting, value);
236)   }
237) 
238)   /**
239)    * @brief process config file
240)    *
241)    * @param[in] configFileName name of config file to read
242)    */
243)   void procFile(String configFileName)
244)     throws Exception
245)   {

246)     FileReader fr = null;
247)     BufferedReader br = null;

248)     String line;
249) 
250)     // check file name

251)     if (configFileName.length() == 0)
252)       error("no config file specified");

253) 

254)     info("using config file \"" + configFileName + "\"");

255) 
256)     // open file
257)     try {
258)       fr = new FileReader(configFileName);
259)       br = new BufferedReader(fr);
260)     } catch (FileNotFoundException e) {

261)       error("cannot open config file \"" + configFileName +
262)             "\" for reading", e);

263)     }
264) 
265)     // read lines and process them
266)     m_lineNo = 1;
267)     while ((line = br.readLine()) != null) {
268)       procLine(line);
269)       ++m_lineNo;
270)     }
271) 
272)     // close file
273)     br.close();
274)     fr.close();
275) 

276)     info(String.format("%dx%d input format, ", m_display.m_size.m_x,
277)                                                m_display.m_size.m_y) +
278)          String.format("%d distributors, ",    m_display.m_distriCnt ) +
279)          String.format("%d outputs, ",         m_display.m_outputCnt ) +
280)          String.format("%d pixels, ",          m_display.m_pixelCnt) +
281)          "\n");
282)   }
283) 
284)   /**
285)    * @brief report error message and throw exception
286)    * @param[in] txt error text
287)    */
288)   private void error(String txt)
289)     throws Exception
290)   {
291)     if (m_messageIf != null)
292)       m_messageIf.message(MsgType.Err, txt + "\n");
293)     throw new Exception(txt);
294)   }
295) 
296)   /**
297)    * @brief report error message and throw exception
298)    * @param[in] txt error text
299)    * @param[in] e reason for error
300)    */
301)   private void error(String txt, Exception e)
302)     throws Exception
303)   {
304)     if (m_messageIf != null)
305)       m_messageIf.message(MsgType.Err, txt + ": " + e.getMessage() + "\n");
306)     throw new Exception(txt, e);
307)   }
308) 
309)   /**
310)    * @brief report warning message
311)    * @param[in] txt warning text
312)    */
313)   private void warning(String txt)
314)   {
315)     if (m_messageIf != null)
316)       m_messageIf.message(MsgType.Warn, txt + "\n");
317)   }
318) 
319)   /**
320)    * @brief report information message
321)    * @param[in] txt information text
322)    */
323)   private void info(String txt)
324)   {

325)     if (m_messageIf != null)

326)       m_messageIf.message(MsgType.Info, txt + "\n");