LEMON/LEMON-main Changeset - r198:e80e08222fdf

Repositories » LEMON » LEMON-main

Summary
Changelog
Files
Switch To
- loading...
Options
- Lightweight changelog
- Search
Pull Requests

Changeset - r198:e80e08222fdf

« 197:5893ba
« 196:420013

201:9757e3 »
199:e3aba2 »

r198:e80e08222fdf

Wed, 09 Jul 2008 07:57:53

[Not Reviewed]

0 comments (0 inline)

alpar (Alpar Juttner)
alpar@cs.elte.hu

Merge

0 2 0

merge default

0 files changed with 14 insertions and 14 deletions:

lemon/lgf_reader.h

lemon/lgf_writer.h

↑ Collapse diff ↑

lemon/lgf_reader.h

Show inline comments

@@ -192,50 +192,50 @@
 			  throw DataFormatError("Item not found");
+			}
 			return _graph.direct(it->second, str[0] == '+');
+		      }
 		    };
 		    bool isWhiteSpace(char c) {
+		    inline bool isWhiteSpace(char c) {
 		      return c == ' ' || c == '\t' || c == '\v' ||
 		        c == '\n' || c == '\r' || c == '\f';
+		    }
 		    bool isOct(char c) {
+		    inline bool isOct(char c) {
 		      return '0' <= c && c <='7';
+		    }
 		    int valueOct(char c) {
+		    inline int valueOct(char c) {
 		      LEMON_ASSERT(isOct(c), "The character is not octal.");
 		      return c - '0';
+		    }
 		    bool isHex(char c) {
+		    inline bool isHex(char c) {
 		      return ('0' <= c && c <= '9') ||
 			('a' <= c && c <= 'z') ||
 			('A' <= c && c <= 'Z');
+		    }
 		    int valueHex(char c) {
+		    inline int valueHex(char c) {
 		      LEMON_ASSERT(isHex(c), "The character is not hexadecimal.");
 		      if ('0' <= c && c <= '9') return c - '0';
 		      if ('a' <= c && c <= 'z') return c - 'a' + 10;
 		      return c - 'A' + 10;
+		    }
 		    bool isIdentifierFirstChar(char c) {
+		    inline bool isIdentifierFirstChar(char c) {
 		      return ('a' <= c && c <= 'z') ||
 			('A' <= c && c <= 'Z') || c == '_';
+		    }
 		    bool isIdentifierChar(char c) {
+		    inline bool isIdentifierChar(char c) {
 		      return isIdentifierFirstChar(c) ||
 			('0' <= c && c <= '9');
+		    }
 		    char readEscape(std::istream& is) {
+		    inline char readEscape(std::istream& is) {
 		      char c;
 		      if (!is.get(c))
 			throw DataFormatError("Escape format error");
 		      switch (c) {
 		      case '\\':
@@ -281,13 +281,13 @@
 			  else code = code * 8 + valueOct(c);
 			  return code;
+			}
+		      }
+		    }
 		    std::istream& readToken(std::istream& is, std::string& str) {
+		    inline std::istream& readToken(std::istream& is, std::string& str) {
 		      std::ostringstream os;
 		      char c;
 		      is >> std::ws;
 		      if (!is.get(c))

lemon/lgf_writer.h

Show inline comments

@@ -222,23 +222,23 @@
	  throw DataFormatError("Item not found");
	}
	return (_graph.direction(val) ? '+' : '-') + it->second;
      }
    };

    bool isWhiteSpace(char c) {
    inline bool isWhiteSpace(char c) {
      return c == ' ' || c == '\t' || c == '\v' || 
        c == '\n' || c == '\r' || c == '\f'; 
    }

    bool isEscaped(char c) {
    inline bool isEscaped(char c) {
      return c == '\\' || c == '\"' || c == '\'' || 
	c == '\a' || c == '\b';
    }

    static void writeEscape(std::ostream& os, char c) {
    inline static void writeEscape(std::ostream& os, char c) {
      switch (c) {
      case '\\':
	os << "\\\\";
	return;
      case '\"':
	os << "\\\"";
@@ -273,25 +273,25 @@
	  os << c;
	}
	return;
      }     
    }

    bool requireEscape(const std::string& str) {
    inline bool requireEscape(const std::string& str) {
      if (str.empty() || str[0] == '@') return true;
      std::istringstream is(str);
      char c;
      while (is.get(c)) {
	if (isWhiteSpace(c) || isEscaped(c)) {
	  return true;
	}
      }
      return false;
    }
    
    std::ostream& writeToken(std::ostream& os, const std::string& str) {
    inline std::ostream& writeToken(std::ostream& os, const std::string& str) {

      if (requireEscape(str)) {
	os << '\"';
	for (std::string::const_iterator it = str.begin(); 
	     it != str.end(); ++it) {
	  writeEscape(os, *it);

0 comments (0 inline)

...	...	@@ -222,23 +222,23 @@
222	222	throw DataFormatError("Item not found");
223	223	}
224	224	return (_graph.direction(val) ? '+' : '-') + it->second;
225	225	}
226	226	};
227	227
228		bool isWhiteSpace(char c) {
	228	inline bool isWhiteSpace(char c) {
229	229	return c == ' ' \|\| c == '\t' \|\| c == '\v' \|\|
230	230	c == '\n' \|\| c == '\r' \|\| c == '\f';
231	231	}
232	232
233		bool isEscaped(char c) {
	233	inline bool isEscaped(char c) {
234	234	return c == '\\' \|\| c == '\"' \|\| c == '\'' \|\|
235	235	c == '\a' \|\| c == '\b';
236	236	}
237	237
238		static void writeEscape(std::ostream& os, char c) {
	238	inline static void writeEscape(std::ostream& os, char c) {
239	239	switch (c) {
240	240	case '\\':
241	241	os << "\\\\";
242	242	return;
243	243	case '\"':
244	244	os << "\\\"";
...	...	@@ -273,25 +273,25 @@
273	273	os << c;
274	274	}
275	275	return;
276	276	}
277	277	}
278	278
279		bool requireEscape(const std::string& str) {
	279	inline bool requireEscape(const std::string& str) {
280	280	if (str.empty() \|\| str[0] == '@') return true;
281	281	std::istringstream is(str);
282	282	char c;
283	283	while (is.get(c)) {
284	284	if (isWhiteSpace(c) \|\| isEscaped(c)) {
285	285	return true;
286	286	}
287	287	}
288	288	return false;
289	289	}
290	290
291		std::ostream& writeToken(std::ostream& os, const std::string& str) {
	291	inline std::ostream& writeToken(std::ostream& os, const std::string& str) {
292	292
293	293	if (requireEscape(str)) {
294	294	os << '\"';
295	295	for (std::string::const_iterator it = str.begin();
296	296	it != str.end(); ++it) {
297	297	writeEscape(os, *it);

RhodeCode

Login to your account