Added socket communication for an interactive mode compiler. Start mo…

…deq with +d=interactive,dump,interactivedump and then telnet to port 29500 to send models to the server. So far the models are not saved anywhere, they are only output if dump flag is set.

git-svn-id: https://openmodelica.org/svn/OpenModelica/trunk@776 f25d12d1-65f4-0310-ae8a-bbce733d8d8e

modeq/Makefile.in

@@ -19,11 +19,11 @@ RMLHOME	= @rmlhome@
 RML	= @rmlc_bin@ -g
 RMLINC  = -I$(RMLHOME)/include/plain
 
-LDFLAGS = -L$(RMLHOME)/lib/plain $(ANTLR_LIBP) -lrml -lm -lantlr
+LDFLAGS = -L$(RMLHOME)/lib/plain $(ANTLR_LIBP) -lrml -lm -lantlr -lsocket -lnsl 
 
 PROG	= modeq
 AST	= absyn_builder/absyn_builder.a
-RTOBJ   = runtime/rtopts.o
+RTOBJ   = runtime/rtopts.o runtime/socketimpl.o
 
 SRCRML= absyn.rml \
 	algorithm.rml \

modeq/absyn_builder/parse.cpp

@@ -67,5 +67,51 @@ RML_BEGIN_LABEL(Parser__parse)
 }
 RML_END_LABEL
 
+RML_BEGIN_LABEL(Parser__parsestring)
+{
+  char* str = RML_STRINGDATA(rmlA0);
+  bool debug = check_debug_flag("parsedump");
+  try 
+    {
+      std::istrstream stream(str);
+
+      modelica_lexer lex(stream);
+      modelica_parser parse(lex);
+      parse.stored_definition();
+      antlr::RefAST t = parse.getAST();
+
+      if (t)
+	{
+	  if (debug)
+	    {
+	      parse_tree_dumper dumper(std::cout);
+	      dumper.dump(t);
+	    }
+
+	  modelica_tree_parser build;
+	  void* ast = build.stored_definition(t);
+
+	  if (debug)
+	    {
+	  std::cout << "Build done\n";
+	    }
+
+	  rmlA0 = ast ? ast : mk_nil();
+
+	  RML_TAILCALLK(rmlSC); 
+	}    
+    } 
+  catch (std::exception &e)
+    {
+      std::cerr << "Error while parsing:\n" << e.what() << "\n";
+    }
+  catch (...)
+    {
+      std::cerr << "Error while parsing\n";
+    }
+  RML_TAILCALLK(rmlFC);
+}
+RML_END_LABEL
+
 } // extern "C"
 

modeq/codegen.rml

@@ -1091,8 +1091,8 @@ relation generate_algorithm_statement : (Algorithm.Statement, int)
 	Util.string_append_list(["simple_index_alloc_",ident_type_str,
 			    "1(&",evar,", ",tvar,", &",ivar,");"]) 
 	  => stmt_array &
-	Util.string_append_list([ivar," = *(",array_type_str,"_element_addr(&",
-			    evar,", 1, ",tvar,");"]) => stmt_scalar &
+	Util.string_append_list([ivar," = *(",array_type_str,"_element_addr1(&",
+			    evar,", 1, ",tvar,");"]) => stmt_scalar & (* Use fast implementation for 1 dim *)
 
 	Util.if(a,stmt_array,stmt_scalar) => stmt &
 	generate_algorithm_statements(stmts,tnr3) => (cfn4,tnr4) &
@@ -1987,6 +1987,32 @@ relation generate_scalar_lhs_cref : (Exp.Type, Exp.ComponentRef, int)
 	generate_scalar_lhs_cref(t,cref,tnr)
 	  => (cfn,var,tnr')
 
+	    (* two special cases rules for 1 and 2 dimensions for faster code (no vararg) *)
+  rule	Debug.fprintln("gcge","generating cref ccode") &
+	generate_indices(idx,tnr) => (cfn1,idxs1,tnr1) &
+	list_length idxs1 => 1 &  (* ndims == 1*)
+	int_string 1 => ndims_str &
+	Util.string_delimit_list(idxs1,", ") => idxs_str &
+	exp_type_str(t,true) => type_str &
+	Util.string_append_list(["(*",type_str,"_element_addr1(&",id,", ",ndims_str,
+			", ",idxs_str,"))"]) => cref1 
+	------------------------------------------------
+	generate_scalar_lhs_cref(t,Exp.CREF_IDENT(id,idx),tnr)
+	  => (cfn1,cref1,tnr1)
+
+  rule	Debug.fprintln("gcge","generating cref ccode") &
+	generate_indices(idx,tnr) => (cfn1,idxs1,tnr1) &
+	list_length idxs1 => 2 & (* ndims == 2 *)
+	int_string 2 => ndims_str &
+	Util.string_delimit_list(idxs1,", ") => idxs_str &
+	exp_type_str(t,true) => type_str &
+	Util.string_append_list(["(*",type_str,"_element_addr2(&",id,", ",ndims_str,
+			", ",idxs_str,"))"]) => cref1 
+	------------------------------------------------
+	generate_scalar_lhs_cref(t,Exp.CREF_IDENT(id,idx),tnr)
+	  => (cfn1,cref1,tnr1)
+
+
   rule	Debug.fprintln("gcge","generating cref ccode") &
 	generate_indices(idx,tnr) => (cfn1,idxs1,tnr1) &
 	list_length idxs1 => ndims &
@@ -2041,6 +2067,32 @@ end
 relation generate_scalar_rhs_cref : (string, Exp.Type,Exp.Subscript list, int) 
 	  => (CFunction, string, int) =
 
+	   (* Two special rules for faster code when ndims == 1 or 2 *)
+
+  rule	generate_indices(subs,tnr) => (cfn1,idxs1,tnr1) &
+	list_length idxs1 => 1 & (* ndims == 1*)
+	int_string 1 => ndims_str &
+	Util.string_delimit_list(idxs1,", ") => idxs_str &
+	exp_type_str (crt,true) => array_type_str &
+	Util.string_append_list(["(*",array_type_str,"_element_addr1(&",
+				 cref_str,", ",ndims_str,
+				 ", ",idxs_str,"))"]) => cref1
+	--------------------
+	generate_scalar_rhs_cref (cref_str,crt,subs,tnr) 
+	  => (cfn1,cref1,tnr1)
+
+  rule	generate_indices(subs,tnr) => (cfn1,idxs1,tnr1) &
+	list_length idxs1 => 2 & (* ndims == 2*)
+	int_string 2 => ndims_str &
+	Util.string_delimit_list(idxs1,", ") => idxs_str &
+	exp_type_str (crt,true) => array_type_str &
+	Util.string_append_list(["(*",array_type_str,"_element_addr2(&",
+				 cref_str,", ",ndims_str,
+				 ", ",idxs_str,"))"]) => cref1
+	--------------------
+	generate_scalar_rhs_cref (cref_str,crt,subs,tnr) 
+	  => (cfn1,cref1,tnr1)
+
   rule	generate_indices(subs,tnr) => (cfn1,idxs1,tnr1) &
 	list_length idxs1 => ndims &
 	int_string ndims => ndims_str &

modeq/debug.rml

@@ -38,6 +38,7 @@ module Debug:
  relation fprintl: (string, string list) => ()
  relation fprint_list: (string, 'a list, 'a => (), string) => ()
  relation fcall: (string, 'a => (), 'a) => ()
+ relation notfcall: (string, 'a => (), 'a) => ()
 end
 
 with "rtopts.rml"
@@ -134,6 +135,18 @@ relation fcall: (string, 'a => (), 'a) => () =
 
 end
 
+(* Call the given function (2nd arg) if the flag given in 1st arg is NOT set *)
+
+relation notfcall: (string, 'a => (), 'a) => () =
+
+  rule	RTOpts.debug_flag (flag) => false &
+	func(str)
+	------------
+	notfcall (flag, func, str)
+
+  axiom	notfcall (_,_,_)
+
+end
 
 relation fprint_list: (string, 'a list, 'a => (), string) => () =
 

modeq/main.rml

@@ -43,6 +43,86 @@ with "inst.rml"
 with "rtopts.rml"
 with "debug.rml"
 with "codegen.rml"
+with "socket.rml"
+
+(** relation: server_loop
+ **
+ ** This relation is the main loop of the server listening to a port
+    which recieves modelica expressions,  
+**)
+
+relation server_loop: int => () =
+
+  rule	Socket.handlerequest shandle => str &
+	Debug.fprint ("interactivedump" ,"------- Recieved Data from client -----\n") &
+	Debug.fprint ("interactivedump" , str ) &
+	Debug.fprint ("interactivedump", "------- End recieved Data-----\n") &
+	handle_command str  => true &
+	Socket.sendreply(shandle,"OK\n") &
+	server_loop shandle 
+	-----------------------------
+	server_loop shandle
+
+  rule  print "Exiting\n" &
+	Socket.sendreply(shandle, "quit requested, shutting server down") &
+	Socket.close shandle
+	---------------------
+	server_loop shandle
+
+end
+
+relation charlistcompare: (char list, char list, int) => bool =
+  rule	a = b
+	-------------------
+	charlistcompare(a::_,b::_,1) => true
+
+  rule	int_sub(n,1) => n1 &
+	a = b &
+	charlistcompare(l1,l2,n1) => true
+	-------------------------------------
+	charlistcompare(a::l1,b::l2,n) => true
+
+  axiom	charlistcompare(_,_,_) => false
+end
+
+relation strncmp: (string,string,int)=>bool =
+  rule	string_list(s1) => clst1 &
+	string_list(s2) => clst2 &
+	string_length(s1) => s1len &
+	string_length(s2) => s2len &
+	int_ge(s1len,n) => true &
+	int_ge(s2len,n) => true &
+	charlistcompare(clst1,clst2,n) => true
+	-------------------------------------
+	strncmp (s1,s2,n) => true
+	axiom strncmp(_,_,_) => false
+end
+(** relation handle_command
+ **
+ ** This relation handles the commands in form of strings send to the server
+ ** If the command is quit, the relation returns false, otherwise it sends the string to the parse relation and returns true.
+**)
+relation handle_command: string => bool =
+  rule	let quitcmd = "quit()" & 
+	string_length(quitcmd) => slen &
+	strncmp("quit()","quit()",6)=> true &
+	strncmp("abc","cde",3) => false &
+	print "Check completed\n" &
+	strncmp("quit()",str,slen) => true 
+	---------------------------
+	handle_command str => false
+
+  rule	Parser.parsestring str => p
+	& Debug.fprint ("dump", "\n--------------- Parsed program ---------------\n")
+	& Debug.fcall ("dumpgraphviz", DumpGraphviz.dump, p)
+	& Debug.fcall ("dump", Dump.dump, p)
+	------------------------------------
+	handle_command str => true
+
+  rule  print "Error occured building AST\n"
+	----------------------------------
+	handle_command _ => true
+end
 
 (** relation: translate_file
  **
@@ -109,7 +189,14 @@ relation fix_modelica_output : DAE.DAElist => DAE.DAElist =
 end
 
 
+relation interactivemode: string list => () =
 
+  rule	Socket.waitforconnect 29500  => shandle &
+	server_loop shandle
+	-------------------
+	interactivemode _
+end
+
 
 (** relation: main
  **
@@ -120,7 +207,8 @@ end
 relation main : string list => () =
 
   rule	RTOpts.args args => args' &
-	translate_file args'
+	Debug.fcall ("interactive", interactivemode, args' ) &
+	Debug.notfcall ("interactive", translate_file, args')
 	--------------------
 	main args
 

modeq/parse.rml

@@ -24,6 +24,7 @@
 module Parser:
   with "absyn.rml"
   relation parse: string => Absyn.Program
+  relation parsestring: string => Absyn.Program
 end
 
 

modeq/runtime/Makefile.in

@@ -12,11 +12,13 @@ SHELL	= /bin/sh
 CC	= gcc
 CFLAGS	= -I$(RMLINCLUDE)
 
-SRC	= rtopts.c
+SRC	= rtopts.c socketimpl.c
 
 OBJ     = $(SRC:.c=.o)
 
 all: $(OBJ)
 
 clean:
 	$(RM) $(OBJ)
+
+