gettc 1.5 → 1.6

data/dist/include/python/topcoder/__init__.py

@@ -0,0 +1,3 @@
+from topcoder.errors import UnsupportedTypeError
+from topcoder.reader import ReadError, Reader
+from topcoder.writer import write

data/dist/include/python/topcoder/errors.py

@@ -0,0 +1,4 @@
+class UnsupportedTypeError(Exception):
+    def __init__(self, type):
+        message = type + " is not a valid TopCoder type"
+        Exception.__init__(self, message)

data/dist/include/python/topcoder/reader.py

@@ -0,0 +1,160 @@
+from topcoder.errors import UnsupportedTypeError
+
+class ReadError(Exception):
+    def __init__(self, text, pos, info = ""):
+        if (pos < len(text)) and (pos >= 0):
+            text = text[:pos] + "|" + text[pos] + "|" + text[(pos + 1):]
+        message = "<" + text + ">"
+        if info:
+            message += " (" + info + ")"
+        Exception.__init__(self, message)
+
+class Reader(object):
+    def __init__(self, text):
+        self._internal = ReaderInternal(text)
+
+    def next(self, type = None):
+        return self._internal.next(type)
+
+class ReaderInternal(object):
+    def __init__(self, text):
+        self.text = text
+        self.pos = 0
+        self.len = len(text)
+
+    def next(self, type = None):
+        if type is None:
+            self.spaces()
+            self.expect(',')
+            return
+
+        if type == "int" or type == "long":
+            return self.next_int()
+        if type == "float" or type == "double":
+            return self.next_float()
+        if type == "char":
+            return self.next_char()
+        if type == "String":
+            return self.next_string()
+        if type == "boolean":
+            return self.next_boolean()
+        if type.endswith("[]"):
+            return self.next_array(type[:-2])
+        
+        raise UnsupportedTypeError(type)
+
+    def raise_here(self, message):
+        raise ReadError(self.text, self.pos, message)
+
+    def check_pos(self):
+        if self.pos >= self.len:
+            self.raise_here("unexpected end of input")
+
+    def token(self):
+        self.check_pos()
+        return self.text[self.pos]
+
+    def spaces(self):
+        while self.pos < self.len and self.token().isspace():
+            self.pos += 1
+
+    def next_digits(self):
+        if not self.token().isdigit():
+            self.raise_here("expecting a digit")
+        begin = self.pos
+        while True:
+            self.pos += 1
+            if self.pos == self.len or not self.token().isdigit():
+                break
+        return self.text[begin:self.pos]
+
+    def next_positive_int(self):
+        return int(self.next_digits())
+            
+    def next_int(self):
+        self.spaces()
+        if self.token() == "-":
+            self.pos += 1
+            return -self.next_positive_int()
+        return self.next_positive_int()
+
+    def next_positive_float(self):
+        s = self.next_digits()
+        if self.pos < self.len:
+            if self.token() == ".":
+                self.pos += 1
+                s += "." + self.next_digits()
+        return float(s)
+
+    def next_float(self):
+        self.spaces()
+        if self.token() == "-":
+            self.pos += 1
+            return -self.next_positive_float()
+        return self.next_positive_float()
+
+    def expect(self, c):
+        if self.token() == c:
+            self.pos += 1
+        else:
+            self.raise_here("expecting <" + c + ">")
+
+    def next_char(self):
+        self.spaces()
+        self.expect("'")
+        c = self.token()
+        self.pos += 1
+        self.expect("'")
+        return c
+
+    def next_boolean(self):
+        self.spaces()
+        if self.text[self.pos:self.pos + 4].upper() == "TRUE":
+            self.pos += 4
+            return True
+        elif self.text[self.pos:self.pos + 5].upper() == "FALSE":
+            self.pos += 5
+            return False
+        self.raise_here("expecting either true or false)")
+
+    def next_string(self):
+        self.spaces()
+        self.expect('"')
+        begin = self.pos
+        while True:
+            if self.pos >= self.len:
+                self.raise_here("expecting a closing quote when reading a string")
+            if self.token() == '"':
+                self.pos += 1
+                saved = self.pos
+                self.spaces()
+                if self.pos == self.len or self.token() == ',' or self.token() == ']': 
+                    self.pos = saved
+                    return self.text[begin:self.pos - 1]
+            else:
+                self.pos += 1
+
+    def next_elems(self, elem_type, array):
+        self.spaces()
+        c = self.token()
+        if c == "]":
+            self.pos += 1
+            return
+        elif c == ",":
+            self.pos += 1
+            array.append(self.next(elem_type))
+            self.next_elems(elem_type, array)
+        else:
+            self.raise_here("expecting either <,> or <]>")
+
+    def next_array(self, elem_type):
+        result = []
+        self.spaces()
+        self.expect("[")
+        self.spaces()
+        if self.token() == "]":
+            self.pos += 1
+            return result
+        result.append(self.next(elem_type))
+        self.next_elems(elem_type, result)
+        return result

data/dist/include/python/topcoder/writer.py

@@ -0,0 +1,13 @@
+from topcoder.errors import UnsupportedTypeError
+
+def write(value, type):
+    if type in ["int", "long", "float", "double", "boolean"]:
+        return str(value)
+    elif type == "char":
+        return "'" + value + "'"
+    elif type == "String":
+        return '"' + value + '"'
+    elif type.endswith("[]"):
+        elem_type = type[:-2]
+        return "[" + ", ".join(map(lambda elem: write(elem, elem_type), value)) + "]"
+    raise UnsupportedTypeError(type)

data/dist/template/bin/runner.sh

@@ -1,3 +1,6 @@
+# runner.sh mode /path/to/solver /path/to/input/dir /path/to/output/dir
+# mode = quiet|verbose|file
+
 mode="$1"
 solver="$2"
 data_d="$3"
@@ -5,14 +8,20 @@ output_d="$4"
 ostream=/dev/null
 
 timeit () {
-    if [ -x /usr/bin/time ]; then
-        /usr/bin/time -o $ostream "$1" "$2" "$3" "$4" "$5" "$6" "$7" "$8" "$9"
+    if [ command -v /usr/bin/time >/dev/null 2>&1 ]; then
+        /usr/bin/time -o /dev/null echo "Testing availability of the time command" >/dev/null
+        if [ $? -eq 0 ]; then
+            /usr/bin/time -o $ostream "$1" "$2" "$3" "$4" "$5" "$6" "$7" "$8" "$9"
+            return
+        fi
     elif [ $mode = 'verbose' ]; then
-        time "$1" "$2" "$3" "$4" "$5" "$6" "$7" "$8" "$9"
-    else
-        "$1" "$2" "$3" "$4" "$5" "$6" "$7" "$8" "$9"
+        if [ command -v time >/dev/null 2>&1 ]; then
+            time "$1" "$2" "$3" "$4" "$5" "$6" "$7" "$8" "$9"
+            return
+        fi
     fi
-} 
+    "$1" "$2" "$3" "$4" "$5" "$6" "$7" "$8" "$9"
+}
 
 puts () {
     echo "$1" > $ostream
@@ -109,5 +118,6 @@ main () {
     fi
 
 }
+
 init
 main

data/dist/template/solve/cpp/Makefile

@@ -1,11 +1,15 @@
-OUTPUT_D=../../build/cpp
-DATA_D=../../data
-COMPILER=g++ -std=gnu++0x -I$$HOME/.gettc/include/cpp
-RUNNER=sh ../../bin/runner.sh
+GETTC_HOME ?= $(HOME)/.gettc
+OUTPUT_D =../../build/cpp
+DATA_D = ../../data
+COMPILER = g++ -std=gnu++0x -I$(GETTC_HOME)/include/cpp
+RUNNER = sh ../../bin/runner.sh
 
 run = $(RUNNER) $1 $(OUTPUT_D)/<%= prob.name %>Runner $(DATA_D)/$2 $(OUTPUT_D)/$2
 
-default : demo
+default : usage
+
+usage :
+	@cat $(GETTC_HOME)/usage
 
 setup :
 	if [ ! -d $(OUTPUT_D) ]; then mkdir -p $(OUTPUT_D); fi

data/dist/template/solve/cpp/{name}.cpp

@@ -1,11 +1,11 @@
 #include <vector>
 #include <string>
 using namespace std;
-<%
-    engine = CppEngine.new func, vars
-%>
-<%=
-    engine.declare
-%> {
-    return <%= func.type.dumb_cpp %>;
-}
+
+class <%= prob.name %> {
+public:
+<%= engine = CppEngine.new func, vars
+    engine.declare %> {
+        return <%= func.type.dumb_cpp %>;
+    }
+};

data/dist/template/solve/cpp/{name}Runner.cpp

@@ -1,26 +1,26 @@
+#include <fstream>
 #include <topcoder>
-using namespace TopCoder;
 #include "<%= prob.name %>.cpp"
-#include <fstream>
-using namespace std;
+namespace tc = TopCoder;
 <%
     engine = CppEngine.new func, vars
 %>
 int main(int argc, char const *argv[]) {
     try {
-        ifstream ifs(argv[1]);
+        std::ifstream ifs(argv[1]);
 <%=
     engine.input.gsub(/^/, ' ' * 8)
 %>
         ifs.close();
 
-        ofstream ofs(argv[2]);
+        std::ofstream ofs(argv[2]);
+        <%= prob.name %> solver;
 <%=
     engine.output.gsub(/^/, ' ' * 8)
 %>
         ofs.close();
-    } catch (exception &e) {
-        cerr << e.what() << endl;
+    } catch (std::exception &e) {
+        std::cerr << e.what() << std::endl;
     }
     return 0;
-}
+}

data/dist/template/solve/haskell/Makefile

@@ -1,11 +1,15 @@
-OUTPUT_D=../../build/haskell
-DATA_D=../../data
-COMPILER=ghc -i$$HOME/.gettc/include/haskell -outputdir $(OUTPUT_D)
-RUNNER=sh ../../bin/runner.sh
+GETTC_HOME ?= $(HOME)/.gettc
+OUTPUT_D = ../../build/haskell
+DATA_D = ../../data
+COMPILER = ghc -i$(GETTC_HOME)/include/haskell -outputdir $(OUTPUT_D)
+RUNNER = sh ../../bin/runner.sh
 
 run = $(RUNNER) $1 $(OUTPUT_D)/<%= prob.name %>Runner $(DATA_D)/$2 $(OUTPUT_D)/$2
 
-default : demo
+default : usage
+
+usage :
+	@cat $(GETTC_HOME)/usage
 
 setup :
 	if [ ! -d $(OUTPUT_D) ]; then mkdir -p $(OUTPUT_D); fi

data/dist/template/solve/haskell/{name}.hs

@@ -4,4 +4,4 @@ module <%= prob.name %> where
 %>
 <%= 
     engine.declare 
-%>
+%>

data/dist/template/solve/haskell/{name}Runner.hs

@@ -1,7 +1,7 @@
-import TopCoder
 import System.Environment (getArgs)
 import System.IO
-import <%= prob.name %>
+import qualified TopCoder as TC
+import qualified <%= prob.name %> (<%= func.name %>)
 <% 
     engine = HaskellEngine.new func, vars 
 %>
@@ -13,15 +13,15 @@ main = do
     args <- getArgs
     hIn <- openFile (head args) ReadMode
     contents <- hGetContents hIn
-    case (parse getVars "variables" contents) of
+    case (TC.parse getVars "parse variables" contents) of
         Left err -> print err
         Right (<%= 
     temp = engine.vars.map do |var| var.name end
     temp.join(', ')
 %>) -> do
             hOut <- openFile (head (tail args)) WriteMode
-            hPutStr hOut $ show $ <%= 
+            hPutStr hOut $ show $ <%= prob.name %>.<%= 
     engine.output 
 %>
             hClose hOut
-    hClose hIn
+    hClose hIn

data/dist/template/solve/java/Makefile

@@ -0,0 +1,18 @@
+GETTC_HOME ?= $(HOME)/.gettc
+
+default : usage
+
+usage :
+	@cat $(GETTC_HOME)/usage
+
+demo :
+	ant demo
+
+sys :
+	ant sys
+
+sysv :
+	ant sysv
+
+clean :
+	ant clean

data/dist/template/solve/java/build.xml

@@ -1,9 +1,13 @@
 <project name="<%= prob.name %>" basedir="." default="demo">
     <property environment="env"/>
-    
+
+    <condition property="gettc.home" value="${env.GETTC_HOME}" else="${env.HOME}/.gettc">
+        <isset property="env.GETTC_HOME" />
+    </condition>
+
     <property name="data.dir" value="${basedir}/../../data"/>
     <property name="output.dir" value="${basedir}/../../build/java"/>
-    <property name="lib" value="${env.HOME}/.gettc/include/java/TopCoder.jar"/>
+    <property name="lib" value="${gettc.home}/include/java/TopCoder.jar"/>
     <property name="java.sh" value="${output.dir}/java.sh"/>
     <property name="runner.sh" value="${basedir}/../../bin/runner.sh"/>
 
@@ -75,4 +79,4 @@ java -cp "`dirname $0`${path.separator}${lib}" <%= prob.name %>Runner $$*
     <target name="clean">
         <delete dir="${output.dir}"/>
     </target>
-</project>
+</project>

data/dist/template/solve/java/{name}.java

@@ -6,4 +6,4 @@
 %> {
         return <%= func.type.dumb_java %>;
     }
-}
+}

data/dist/template/solve/java/{name}Runner.java

@@ -29,4 +29,4 @@ public class <%= prob.name %>Runner {
         err.printStackTrace(System.err);
     }
     }    
-}
+}

data/dist/template/solve/python/Makefile

@@ -0,0 +1,27 @@
+GETTC_HOME ?= $(HOME)/.gettc
+OUTPUT_D = ../../build/python
+DATA_D = ../../data
+RUNNER = sh ../../bin/runner.sh
+
+run = $(RUNNER) $1 ./<%= prob.name %>Runner.py $(DATA_D)/$2 $(OUTPUT_D)/$2
+
+setup :
+	if [ ! -d $(OUTPUT_D) ]; then mkdir -p $(OUTPUT_D); fi
+	chmod +x <%= prob.name %>Runner.py
+
+default : usage
+
+usage :
+	@cat $(GETTC_HOME)/usage
+
+demo : setup
+	$(call run,verbose,demo) 
+
+sys : setup
+	$(call run,quiet,sys)
+
+sysv : setup
+	$(call run,verbose,sys)
+
+clean :
+	rm -rf $(OUTPUT_D)

data/dist/template/solve/python/{name}.py

@@ -0,0 +1,4 @@
+<%
+    engine = PythonEngine.new func, vars
+%>def <%= func.name %>(<%= engine.vars_list %>):
+    return <%= func.type.dumb_python %>