finalyze moving

projects/dvm/fdvm/trunk/Sage/lib/newsrc/CMakeLists.txt

@@ -0,0 +1,16 @@
+set(SAGE_SOURCES low_level.c unparse.c)
+
+if(MSVC_IDE)
+  foreach(DIR ${DVM_SAGE_INCLUDE_DIRS})
+    file(GLOB_RECURSE FILES RELATIVE ${CMAKE_CURRENT_SOURCE_DIR}
+      "${DIR}/*.h" "${DIR}/*.def" "${DIR}/head" "${DIR}/tag")
+    set(SAGE_HEADERS ${SAGE_HEADERS} ${FILES})
+  endforeach()
+  source_group("Header Files" FILES ${SAGE_HEADERS})
+endif()
+
+add_library(sage ${SAGE_SOURCES} ${SAGE_HEADERS})
+
+target_compile_definitions(sage PRIVATE SYS5)
+target_include_directories(sage PUBLIC "${DVM_SAGE_INCLUDE_DIRS}")
+set_target_properties(sage PROPERTIES FOLDER "${DVM_LIBRARY_FOLDER}")

projects/dvm/fdvm/trunk/Sage/lib/newsrc/Makefile

@@ -0,0 +1,83 @@
+#######################################################################
+##                  pC++/Sage++  Copyright (C) 1993                  ##
+##  Indiana University  University of Oregon  University of Rennes   ##
+#######################################################################
+
+
+# sage/lib/newsrc/Makefile (phb)
+
+LSX = .a
+
+#HP_CFLAGS#CEXTRA = -Aa +z#ENDIF#
+#HP_CFLAGS#LSX = .sl#ENDIF#
+
+SHELL = /bin/sh
+CONFIG_ARCH=iris4d
+
+# ALPHA Sage new lib.a   modified by Pete Beckman (2/1/93)
+
+RANLIB_TEST = [ -f /usr/bin/ranlib ] || [ -f /bin/ranlib ]
+#NO_RANLIB#RANLIB_TEST = (exit 1)#ENDIF#
+
+CC = gcc
+#CC=cc#ENDIF##USE_CC#
+
+CXX = g++
+CXX = /usr/WorkShop/usr/bin/DCC
+OLDHEADERS = ../../h
+
+#INSTALLDEST = ../$(CONFIG_ARCH)
+INSTALLDEST = ../../../libsage
+INSTALL = /bin/cp
+
+# Directory in which include file can be found
+toolbox_include = ../include
+
+INCLUDE = -I$(OLDHEADERS) -I../include
+CFLAGS	= $(INCLUDE) -g -Wall $(CEXTRA)
+LDFLAGS	= 
+BISON= /usr/freeware/bin/bison
+BISON= bison
+TOOLBOX_SRC	=  comments.c low_level.c unparse.c toolsann.c annotate.tab.c
+
+TOOLBOX_HDR     =  $(toolbox_include)/macro.h $(toolbox_include)/bif_node.def  $(toolbox_include)/type.def  $(toolbox_include)/symb.def 
+
+TOOLBOX_OBJ	=  low_level.o  unparse.o 
+
+TOOLBOX_OBJ_ANN	=  comments.o toolsann.o annotate.tab.o
+
+all: libsage$(LSX) 
+
+clean:
+	/bin/rm -f *.o lib*$(LSX)
+
+low_level.o: low_level.c $(TOOLBOX_HDR)
+
+unparse.o:   unparse.c $(TOOLBOX_HDR) $(toolbox_include)/unparse.def $(toolbox_include)/unparseC++.def
+
+main.o : main.c 
+
+libsage : libsage$(LSX)
+
+libsage.a:      $(TOOLBOX_OBJ) $(TOOLBOX_HDR)
+		/bin/rm -f libsage.a
+		ar qc libsage.a $(TOOLBOX_OBJ)
+		@if $(RANLIB_TEST) ; then ranlib libsage.a ; \
+	           else echo "\tNOTE: ranlib not required" ; fi
+
+libsage.sl:     $(TOOLBOX_OBJ) $(TOOLBOX_HDR)
+		/bin/rm -f libsage.sl
+		ld -b -s -o libsage.sl $(TOOLBOX_OBJ)
+
+
+install: $(INSTALLDEST)/libsage$(LSX) 
+
+$(INSTALLDEST)/libsage$(LSX): libsage$(LSX)
+	if [ -d $(INSTALLDEST) ] ; then true; else mkdir $(INSTALLDEST) ;fi
+	$(INSTALL) libsage$(LSX) $(INSTALLDEST)/libsage$(LSX)
+	@if $(RANLIB_TEST) ; then ranlib $(INSTALLDEST)/libsage$(LSX) ; \
+           else echo "\tNOTE: ranlib not required" ; fi
+
+
+
+

projects/dvm/fdvm/trunk/Sage/lib/newsrc/annotate.tab.h

@@ -0,0 +1,74 @@
+typedef union { 
+         int       token ;
+         char      charv ;
+         char      *charp;
+         PTR_BFND   bfnode ;
+         PTR_LLND   ll_node ;
+         PTR_SYMB   symbol  ;
+         PTR_TYPE   data_type ;
+         PTR_HASH   hash_entry ;
+         PTR_LABEL  label ;        
+         PTR_BLOB   blob_ptr ;
+       } YYSTYPE;
+#define	IFDEFA	258
+#define	APPLYTO	259
+#define	ALABELT	260
+#define	SECTIONT	261
+#define	SPECIALAF	262
+#define	FROMT	263
+#define	TOT	264
+#define	TOTLABEL	265
+#define	TOFUNCTION	266
+#define	DefineANN	267
+#define	IDENTIFIER	268
+#define	TYPENAME	269
+#define	SCSPEC	270
+#define	TYPESPEC	271
+#define	TYPEMOD	272
+#define	CONSTANT	273
+#define	STRING	274
+#define	ELLIPSIS	275
+#define	SIZEOF	276
+#define	ENUM	277
+#define	STRUCT	278
+#define	UNION	279
+#define	IF	280
+#define	ELSE	281
+#define	WHILE	282
+#define	DO	283
+#define	FOR	284
+#define	SWITCH	285
+#define	CASE	286
+#define	DEFAULT_TOKEN	287
+#define	BREAK	288
+#define	CONTINUE	289
+#define	RETURN	290
+#define	GOTO	291
+#define	ASM	292
+#define	CLASS	293
+#define	PUBLIC	294
+#define	FRIEND	295
+#define	ACCESSWORD	296
+#define	OVERLOAD	297
+#define	OPERATOR	298
+#define	COBREAK	299
+#define	COLOOP	300
+#define	COEXEC	301
+#define	LOADEDOPR	302
+#define	MULTIPLEID	303
+#define	MULTIPLETYPENAME	304
+#define	ASSIGN	305
+#define	OROR	306
+#define	ANDAND	307
+#define	EQCOMPARE	308
+#define	ARITHCOMPARE	309
+#define	LSHIFT	310
+#define	RSHIFT	311
+#define	UNARY	312
+#define	PLUSPLUS	313
+#define	MINUSMINUS	314
+#define	HYPERUNARY	315
+#define	DOUBLEMARK	316
+#define	POINTSAT	317
+
+extern YYSTYPE yylval;

projects/dvm/fdvm/trunk/Sage/lib/newsrc/comments.c

@@ -0,0 +1,694 @@
+/*********************************************************************/
+/*                  pC++/Sage++  Copyright (C) 1993,1995             */
+/*  Indiana University  University of Oregon  University of Rennes   */
+/*********************************************************************/
+
+
+/* Created By Jenq-Kuen Lee  April 14, 1988     */
+/* A Sub-program to help yylex() catch all the comments */
+/* A small finite automata used to identify the input token corresponding to */
+/* Bif node position */
+
+#include <stdio.h>
+#include "vparse.h"
+#include "vpc.h"
+#include "db.h"
+#include "vextern.h"
+#include "annotate.tab.h"
+
+extern void Message(char *s, int l);
+
+void reset_semicoln_handler();
+void reset();
+int class_struct(int value);
+int is_declare(int value);
+int declare_symb(int value);
+int block_like(int state);
+int keep_original(int state);
+
+int lastdecl_id; /* o if no main_type appeared */
+int left_paren ;
+static int cur_state ;
+int cur_counter;
+
+struct {
+         PTR_CMNT stack[MAX_NESTED_SIZE];
+         int      counter[MAX_NESTED_SIZE];
+	 int      node_type[MAX_NESTED_SIZE];
+	 int      automata_state[MAX_NESTED_SIZE];
+         int      top ;
+       }  comment_stack ;
+
+
+struct {
+         PTR_CMNT stack[MAX_NESTED_SIZE + 1 ];
+         int      front ;
+         int      rear ;
+       }  comment_queue;
+
+struct {
+         int      line_stack[MAX_NESTED_SIZE + 1 ];
+	 PTR_FNAME file_stack[MAX_NESTED_SIZE + 1 ];
+         int      front ;
+         int      rear ;
+	 int      BUGGY[100]; /* This is included because some versions of
+                                 gcc seemed to have bugs that overwrite
+                                 previous fields without.  */
+       }  line_queue;
+
+
+PTR_FNAME find_file_entry()
+{
+  /* dummy, should not be use after cleaning */
+  return NULL;
+}
+
+
+void put_line_queue(line_offset,name)
+int line_offset ;
+char *name;
+{  PTR_FNAME find_file_entry();
+
+   if (line_queue.rear == MAX_NESTED_SIZE) line_queue.rear = 0;
+   else line_queue.rear++;
+   if (line_queue.rear == line_queue.front) Message("stack/queue overflow",0);
+   line_queue.line_stack[line_queue.rear] = line_offset ;
+   line_queue.file_stack[line_queue.rear] = find_file_entry(name);
+}
+
+
+PTR_FNAME
+fetch_line_queue(line_ptr )
+int *line_ptr;
+{
+   if (line_queue.front == line_queue.rear)
+     { *line_ptr = line_queue.line_stack[line_queue.front] ;
+       return(line_queue.file_stack[line_queue.front]);
+     }
+   if (line_queue.front == MAX_NESTED_SIZE) line_queue.front = 0;
+   else line_queue.front++;
+   *line_ptr = line_queue.line_stack[line_queue.front] ;
+   return(line_queue.file_stack[line_queue.front]);
+}
+
+
+void push_state()
+{
+  comment_stack.top++;
+  comment_stack.stack[  comment_stack.top ] = cur_comment ;
+  comment_stack.counter[  comment_stack.top ] = cur_counter ;
+  comment_stack.automata_state[  comment_stack.top ] = cur_state ;
+}
+
+void pop_state()
+{  
+  
+   cur_comment  =  comment_stack.stack[  comment_stack.top ] ;
+   cur_counter =  comment_stack.counter[  comment_stack.top ] ;
+   cur_state  =  comment_stack.automata_state[  comment_stack.top ]  ;
+   comment_stack.top--;
+	
+}
+
+void init_stack()
+{
+  comment_stack.top = 0 ;
+  comment_stack.automata_state[  comment_stack.top ] = ZERO;
+}
+
+
+
+void automata_driver(value)
+int value ;
+{
+ int shift_flag  ;
+ int temp_state ;
+
+
+
+ for (shift_flag = ON  ; shift_flag==ON ;    )
+{  shift_flag = OFF ;
+
+   switch(cur_state) {
+
+   case ZERO :
+
+             switch (value) {
+             case IF :
+                   put_line_queue(line_pos_1,line_pos_fname); 
+                   cur_state = IF_STATE;
+                   break ;
+	     case ELSE :
+                   put_line_queue(line_pos_1,line_pos_fname); 
+                   cur_state = ELSE_EXPECTED_STATE ;
+                   break;
+             case DO :
+                   put_line_queue(line_pos_1,line_pos_fname); 
+                   cur_state = DO_STATE ;
+		   break;
+	     case FOR :
+                   put_line_queue(line_pos_1,line_pos_fname); 
+                   cur_state = FOR_STATE ;
+		   break;
+             case CASE :
+             case DEFAULT_TOKEN:
+                   put_line_queue(line_pos_1,line_pos_fname); 
+                   cur_state = CASE_STATE;
+                   break;
+             case GOTO :
+                   put_line_queue(line_pos_1,line_pos_fname); 
+                   cur_state = GOTO_STATE;
+		   break;
+             case WHILE :
+                   put_line_queue(line_pos_1,line_pos_fname); 
+                   cur_state = WHILE_STATE;
+		   break;
+             case SWITCH:
+                   put_line_queue(line_pos_1,line_pos_fname); 
+                   cur_state = SWITCH_STATE;
+		   break;
+	     case COEXEC :
+                   cur_state = COEXEC_STATE ;
+                   put_line_queue(line_pos_1,line_pos_fname); 
+		   break;
+	     case COLOOP:
+                   put_line_queue(line_pos_1,line_pos_fname); 
+                   cur_state = COLOOP_STATE ;
+		   break;
+	     case RETURN:
+                   put_line_queue(line_pos_1,line_pos_fname); 
+                   cur_state = RETURN_STATE ;
+		   break;
+             case '}':
+                   pop_state();
+		   switch (cur_state) {
+		   case ELSE_EXPECTED_STATE:
+		     put_line_queue(line_pos_1,line_pos_fname); 
+		     break;
+		   case STATE_4:
+		   case BLOCK_STATE:
+		     put_line_queue(line_pos_1,line_pos_fname); 
+		     reset();
+		     reset_semicoln_handler();
+		     break;
+		   case IF_STATE_4:
+		     cur_state= ELSE_EXPECTED_STATE;
+		     put_line_queue(line_pos_1,line_pos_fname); 
+		     break;
+		   case DO_STATE_1:
+		     cur_state= DO_STATE_2;
+		     reset_semicoln_handler();
+		     break;
+		   case DO_STATE_2:
+		   case STATE_2:
+		     break;
+		   default:
+		     reset();
+		     reset_semicoln_handler();
+		   }
+
+                   break ;
+
+		 case '{':    
+                   temp_state=comment_stack.automata_state[comment_stack.top];
+                   if (temp_state == STATE_ARG)
+		      comment_stack.automata_state[comment_stack.top]= STATE_4;
+                   else {   cur_state = BLOCK_STATE ;
+                            put_line_queue(line_pos_1,line_pos_fname); 
+                            push_state();
+			  }
+                   reset();
+                   break ;
+             case '(':
+                   put_line_queue(line_pos_1,line_pos_fname); 
+                   cur_state = STATE_15;
+                   left_paren++;
+                   break;
+             case IDENTIFIER:
+                   put_line_queue(line_pos_1,line_pos_fname); 
+                   cur_state = STATE_6 ;
+		   break;
+             case ';':
+		   reset_semicoln_handler();
+		   break;
+             default : /* other */
+                   put_line_queue(line_pos_1,line_pos_fname); 
+                   if (class_struct(value)) cur_state = STATE_10 ;
+                   else                     cur_state =  STATE_1 ; 
+                   break;
+		 }
+              break;
+  case STATE_1 :
+          if (value == '(')     {   cur_state =STATE_15 ;
+                                    left_paren++;
+				  }
+          if (class_struct(value))  cur_state =STATE_10 ;
+          if (value == IDENTIFIER)  cur_state =STATE_2 ;
+          if (value == OPERATOR)    cur_state =STATE_4 ;
+	  if (value ==';')  reset_semicoln_handler();
+	     break ;
+
+  case STATE_2 :
+          if (value == '(')    {    cur_state = STATE_15 ;
+				    left_paren++;
+				  }
+	  if (value ==';')  { 
+	    reset();
+	    reset_semicoln_handler();
+	  }
+          break;
+
+  case STATE_4:
+          switch (value) {
+          case  '(':
+                 cur_state =  STATE_15 ;
+                 left_paren++;
+		 break;
+          case '{':         /*  cur_state = STATE_5; */
+	         push_state();
+                 reset();
+		 break;
+	  case  '=':
+          case  ',':
+                 cur_state = STATE_12;
+                 break;
+	       case  ';':
+		 reset_semicoln_handler();
+		 break;
+          default:
+              if (is_declare(value))
+	        {  cur_state = STATE_ARG ;
+                   push_state();
+		   reset();
+		 }
+	      else      cur_state = STATE_12;
+	     }
+	   
+          break;
+   case STATE_6:
+          if (value == ':') cur_state = ZERO;
+          else {
+	    if (value ==';') reset_semicoln_handler();
+	    else {  cur_state = STATE_2;
+                      shift_flag = ON ;
+		    }
+	  }
+          break;
+  case STATE_10 :
+          if (value =='{')
+	    { cur_state = STATE_2 ;
+	      push_state();
+	      reset();
+	    }
+          if ((value == '=' )||(value ==','))  cur_state = STATE_12;
+	  if (value == '(' )    {     cur_state = STATE_15;
+					 left_paren++;
+				       }
+	  if (value ==';') reset_semicoln_handler();
+	  break ;
+  case STATE_12:
+	  if (value ==';') reset_semicoln_handler();
+           break ;
+
+  case  STATE_15 :
+           if (value == '(') left_paren++ ;
+           if (value == ')')  left_paren--;
+           if (left_paren == 0) cur_state = STATE_4 ;
+           break ;
+  case IF_STATE:
+           if (value == '(') { left_paren++;
+                               cur_state = IF_STATE_2;
+			     }
+           break;
+  case IF_STATE_2:
+           if (value == '(') left_paren++ ;
+           if (value == ')')  left_paren--;
+           if (left_paren == 0) cur_state = IF_STATE_3 ;
+           break ;
+  case IF_STATE_3:
+	     if (value == ';') {
+	       put_line_queue(line_pos_1,line_pos_fname); 
+	       cur_state= ELSE_EXPECTED_STATE ;
+	     }
+           if (value =='{') {  cur_state= ELSE_EXPECTED_STATE ;
+                               push_state();
+			       cur_state = ZERO ; /* counter continuing */
+			     }
+           if (cur_state == IF_STATE_3) 
+	     {  cur_state = IF_STATE_4 ;
+                push_state();
+                reset();
+		shift_flag = ON;
+	      }
+           break;
+
+  case ELSE_EXPECTED_STATE:
+           if (value == ELSE) cur_state = BLOCK_STATE ;
+           else  { 
+	     reset();
+	     reset_semicoln_handler();
+	     shift_flag = ON ;
+	   }
+           break;
+
+  case BLOCK_STATE:
+	  if (value ==';') {
+	    cur_state =  BLOCK_STATE_WAITSEMI;
+	    push_state();
+	    reset_semicoln_handler();
+	  }
+	  if (value == '{') { push_state();
+			      reset();
+			    }
+          if (cur_state == BLOCK_STATE)
+	    {  
+	      cur_state =  BLOCK_STATE_WAITSEMI;
+	      push_state();
+	      reset();
+	      shift_flag = ON ;
+	    }
+	  break;
+	     
+  case WHILE_STATE:
+           if (value == '('){ left_paren++;
+                              cur_state = WHILE_STATE_2;
+			    }
+           break;
+  case WHILE_STATE_2:
+           if (value == '(') left_paren++ ;
+           if (value == ')')  left_paren--;
+           if (left_paren == 0) cur_state = BLOCK_STATE ;
+           break ;
+
+  case FOR_STATE:
+           if (value == '(') { left_paren++;
+                               cur_state = FOR_STATE_2;
+			     }
+           break;
+  case FOR_STATE_2:
+           if (value == '(') left_paren++ ;
+           if (value == ')')  left_paren--;
+           if (left_paren == 0) cur_state = BLOCK_STATE ;
+           break ;
+
+  case COLOOP_STATE:
+           if (value == '(') { left_paren++;
+			       cur_state = COLOOP_STATE_2;
+			     }
+           break;
+  case COLOOP_STATE_2:
+           if (value == '(') left_paren++ ;
+           if (value == ')')  left_paren--;
+           if (left_paren == 0) cur_state = BLOCK_STATE ;
+           break ;
+
+  case COEXEC_STATE:
+           if (value == '(') { left_paren++;
+			       cur_state = COEXEC_STATE_2;
+			     }
+           break;
+  case COEXEC_STATE_2:
+           if (value == '(') left_paren++ ;
+           if (value == ')')  left_paren--;
+           if (left_paren == 0) cur_state = BLOCK_STATE ;
+           break ;
+
+  case SWITCH_STATE:
+           if (value == '(') { left_paren++;
+			       cur_state = SWITCH_STATE_2;
+			     }
+           break;
+  case SWITCH_STATE_2:
+           if (value == '(') left_paren++ ;
+           if (value == ')')  left_paren--;
+           if (left_paren == 0) cur_state = BLOCK_STATE ;
+           break ;
+
+  case CASE_STATE :
+           if (value == ':') reset();
+           break;
+  case DO_STATE : /* Need More, some problem exists */
+           if (value == ';') { cur_state = DO_STATE_2 ; }
+           if (value == '{') { cur_state = DO_STATE_2 ;
+                               push_state();
+                               reset();
+			     }
+           if (cur_state == DO_STATE)
+	     { cur_state = DO_STATE_1 ;
+	       push_state();
+	       reset();
+	       shift_flag = ON;
+	     }
+           break;
+   case DO_STATE_2:
+           if (value == WHILE) cur_state= DO_STATE_3 ;
+           break ;
+   case DO_STATE_3:
+	   if (value == '(') { cur_state = DO_STATE_4 ; 
+                               left_paren++;
+			     }
+           break;
+   case DO_STATE_4:
+           if (value == '(') left_paren++ ;
+           if (value == ')')  left_paren--;
+           if (left_paren == 0) cur_state = DO_STATE_5 ;
+           break ;
+   case DO_STATE_5:
+	  if (value ==';') 
+	    { 
+	      put_line_queue(line_pos_1,line_pos_fname); 
+	      reset();
+	      reset_semicoln_handler();
+	    }
+           break;
+   case RETURN_STATE:
+	  if (value ==';') reset_semicoln_handler();
+	  if (value == '(') { left_paren++;
+                                cur_state = RETURN_STATE_2 ;
+			     }
+           break;
+   case RETURN_STATE_2:
+           if (value == '(') left_paren++ ;
+           if (value == ')')  left_paren--;
+           if (left_paren == 0) cur_state = RETURN_STATE_3 ;
+           break ;
+   case RETURN_STATE_3:
+	     if (value ==';') reset_semicoln_handler();
+           break;
+   case GOTO_STATE:
+           if (value == IDENTIFIER) cur_state = GOTO_STATE_2 ;
+           break;
+   case GOTO_STATE_2:
+	     if (value ==';') reset_semicoln_handler();
+           break;
+   default:
+           Message(" comments state un_expected...",0);
+           break;
+	   }
+
+
+ }
+
+}
+
+int class_struct(int value)
+{
+  switch (value) {
+  case ENUM :
+  case CLASS:
+  case STRUCT :
+  case UNION: return(1);
+  default : return(0);
+  }
+}
+
+int declare_symb(int value)
+{
+  switch (value) {
+  case TYPENAME :
+  case TYPESPEC:
+  case TYPEMOD:
+  case ACCESSWORD:
+  case SCSPEC:
+  case ENUM :
+  case CLASS:
+  case STRUCT :
+  case UNION: return(1);
+  default : return(0);
+  }
+}
+
+
+void reset()
+{
+   cur_state = 0 ;
+   cur_counter = 0 ;
+   cur_comment     = (PTR_CMNT) NULL ; 
+
+/*   put_line_queue(line_pos_1,line_pos_fname); */
+ }
+
+int block_like(int state)
+{
+
+   switch( state) {
+   case BLOCK_STATE:
+   case ZERO:
+   case SWITCH_STATE:
+   case FOR_STATE :
+   case WHILE_STATE :
+   case COEXEC_STATE :
+   case COLOOP_STATE:
+   case STATE_4: /* end of function_body */
+            return(1);
+   default: return(0);
+ }
+}
+
+int is_declare(int value)
+{
+  switch (value) {
+  case   TYPENAME:
+  case   TYPESPEC :
+  case   ACCESSWORD:
+  case   SCSPEC:
+  case   TYPEMOD:
+  case   ENUM:
+  case   UNION:
+  case   CLASS:
+  case   STRUCT:  return(1);
+    default :     return(0);
+  }
+}
+
+
+
+/* pop state until reach a stable state BLOCK_STATE or ZERO        */
+void reset_semicoln_handler()
+{
+  int sw,state;
+
+  for (sw=1; sw;  )
+    {
+      if (keep_original(cur_state)) return;
+      state = comment_stack.automata_state[comment_stack.top];
+      switch (state) {
+      case IF_STATE_4:
+	pop_state();
+	cur_state = ELSE_EXPECTED_STATE ;
+	put_line_queue(line_pos_1,line_pos_fname); 
+	break;
+      case  DO_STATE_1:
+	pop_state();
+	cur_state = DO_STATE_2 ;
+	break;
+      case BLOCK_STATE_WAITSEMI:
+	put_line_queue(line_pos_1,line_pos_fname); 
+	pop_state();
+	reset();
+	break;
+      default :
+	reset();
+	sw = 0 ;
+      }
+    }
+
+}
+
+
+int keep_original(int state)
+{
+  switch (state) {
+  case ELSE_EXPECTED_STATE:
+  case DO_STATE_2:
+  case STATE_2:
+       return(1);
+ default:
+       return(0);
+     }
+}
+
+
+
+
+
+/*****************************************************************************/
+/* is_at_decl_state() & is_look_ahead_of_identifier()                        */
+/* These two routines are used in yylex to identify if a TYPENAME is just    */
+/* a IDENTIFIER                                                              */
+/*                                                                           */
+/*****************************************************************************/
+int
+is_at_decl_state()
+{
+
+  /* to see if it is inside (, )  */
+  switch(cur_state) {
+  case STATE_15:
+  case IF_STATE_2:
+  case WHILE_STATE_2:
+  case FOR_STATE_2:
+  case COLOOP_STATE_2:
+  case COEXEC_STATE_2:
+  case SWITCH_STATE_2:
+  case DO_STATE_4:
+    return(0);
+  default:
+    return(1);
+  }
+}
+
+
+int is_look_ahead_of_identifier(c)
+char c;
+{
+  switch (c) {
+  case ':' :
+  case '(':
+  case '[':
+  case ',':
+  case ';':
+  case '=':
+    return(1);
+  default:
+    return(0);
+  }
+
+}
+
+
+void set_up_momentum(value,token)
+int value,token;
+{
+
+  if (lastdecl_id == 0)
+    {
+      /* check if main_type appears */
+       switch (value) {
+       case TYPESPEC:
+	 lastdecl_id = 1;
+	 break;
+       case TYPEMOD:
+	 if ((token == (int)RID_LONG)||(token == (int)RID_SHORT)||
+	     (token==(int)RID_SIGNED)||(token==(int)RID_UNSIGNED))
+         lastdecl_id = 1;
+	 break;
+       }
+     }
+  else
+    {
+      /* case for main_type already appear, then check if 
+	 1. this is still a decl.
+	 2. reset it to wait for another decl stat.   */
+      switch (value) {
+      case TYPESPEC:
+      case TYPEMOD:
+      case SCSPEC:
+	break;
+      default:
+	lastdecl_id = 0;
+      }
+    }
+
+}
+

projects/dvm/fdvm/trunk/Sage/lib/newsrc/makefile.uni

@@ -0,0 +1,40 @@
+#######################################################################
+##                             Copyright (C) 1999                    ##
+##              Keldysh Institute of Appllied Mathematics            ##
+#######################################################################
+
+# sage/lib/newsrc/makefile.sgi
+
+LIBDIR = ../../../lib
+
+OLDHEADERS = ../../h
+
+# Directory in which include file can be found
+TOOLBOX_INCLUDE = ../include
+
+INCL = -I$(OLDHEADERS) -I../include
+
+TOOLBOX_SRC	=  low_level.c unparse.c 
+
+TOOLBOX_HDR =  $(TOOLBOX_INCLUDE)/macro.h $(TOOLBOX_INCLUDE)/bif_node.def \
+	$(TOOLBOX_INCLUDE)/type.def  $(TOOLBOX_INCLUDE)/symb.def 
+
+CFLAGS = $(INCL) -c -DSYS5 -Wall
+
+low_level.o: low_level.c $(TOOLBOX_HDR)
+
+unparse.o:   unparse.c $(TOOLBOX_HDR) $(TOOLBOX_INCLUDE)/unparse.def \
+	 $(TOOLBOX_INCLUDE)/unparseC++.def
+
+TOOLBOX_OBJ	=  low_level.o  unparse.o 
+
+$(LIBDIR)/libsage.a: $(TOOLBOX_OBJ) $(TOOLBOX_HDR)  
+	ar qc $(LIBDIR)/libsage.a $(TOOLBOX_OBJ) 
+
+all: $(LIBDIR)/libsage.a
+	@echo "*** COMPILING LIBRARY newsrc DONE"
+
+clean:
+	rm -f $(TOOLBOX_OBJ)
+cleanall:
+	rm -f $(TOOLBOX_OBJ)

projects/dvm/fdvm/trunk/Sage/lib/newsrc/makefile.win

@@ -0,0 +1,54 @@
+#######################################################################
+##                             Copyright (C) 1999                    ##
+##              Keldysh Institute of Appllied Mathematics            ##
+#######################################################################
+
+# sage/lib/newsrc/makefile.win
+
+OUTDIR = ../../../obj
+LIBDIR = ../../../lib
+
+OLDHEADERS = ../../h
+
+# Directory in which include file can be found
+TOOLBOX_INCLUDE = ../include
+
+INCL = -I$(OLDHEADERS) -I../include
+
+TOOLBOX_SRC	=  low_level.c unparse.c 
+
+TOOLBOX_HDR =  $(TOOLBOX_INCLUDE)/macro.h $(TOOLBOX_INCLUDE)/bif_node.def \
+	$(TOOLBOX_INCLUDE)/type.def  $(TOOLBOX_INCLUDE)/symb.def 
+
+# -w don't issue warning now.
+#CFLAGS=/nologo /ML /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D SYS5 $(INCL) \
+#	/Fp"$(OUTDIR)/newsrc.pch" /YX /Fo"$(OUTDIR)/" /Fd"$(OUTDIR)/" /c 
+CFLAGS=/nologo /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D SYS5 $(INCL) \
+	/Fp"$(OUTDIR)/newsrc.pch" /Fo"$(OUTDIR)/" /Fd"$(OUTDIR)/" /c 
+
+.c{$(OUTDIR)/}.obj:
+    $(CC) $(CFLAGS) $<
+
+LIB32=$(LINKER) -lib
+LIB32_FLAGS=/nologo /out:"$(LIBDIR)/libsage.lib" 
+
+
+$(OUTDIR)/low_level.obj: low_level.c $(TOOLBOX_HDR)
+
+$(OUTDIR)/unparse.obj:   unparse.c $(TOOLBOX_HDR) $(TOOLBOX_INCLUDE)/unparse.def \
+	 $(TOOLBOX_INCLUDE)/unparseC++.def
+
+TOOLBOX_OBJ	=  $(OUTDIR)/low_level.obj  $(OUTDIR)/unparse.obj 
+
+$(LIBDIR)/libsage.lib: $(TOOLBOX_OBJ) $(TOOLBOX_HDR)  
+	$(LIB32) @<<
+	$(LIB32_FLAGS) $(TOOLBOX_OBJ)  
+<<
+
+all: $(LIBDIR)/libsage.lib
+    @echo "*** COMPILING LIBRARY newsrc DONE"
+
+
+clean:
+
+cleanall: