Changeset 266 for trunk/idl-compiler

Timestamp:

Mar 25, 2007, 1:07:25 AM (18 years ago)

Author:

cinc

Message:

Getting along with parsing

Location:

trunk/idl-compiler

Files:

• Makefile (modified) (1 diff)
• c/nom-idl-compiler.c (modified) (11 diffs)
• include/parser.h (modified) (3 diffs)
• parser_c/interface_parser.c (modified) (5 diffs)
• parser_c/lineinfo_parser.c (modified) (3 diffs)

trunk/idl-compiler/Makefile

@@ -59 +59 @@
 
 
-$(OBJDIR)/%.o:  $(CDIR)/%.c
+$(OBJDIR)/%.o:  $(CDIR)/%.c $(INCDIR)/parser.h
         $(CC) -I $(INC) $(CFLAGS)  -o$@ $<
 
-$(OBJDIR)/%.o:  $(PARSERDIR)/%.c
+$(OBJDIR)/%.o:  $(PARSERDIR)/%.c $(INCDIR)/parser.h
         $(CC) -I $(INC) $(CFLAGS)  -o$@ $<
 

trunk/idl-compiler/c/nom-idl-compiler.c

@@ -83 +83 @@
   {"NOMINSTANCEVAR", IDL_SYMBOL_INSTANCEVAR, KIND_UNKNOWN},
   {"NOMOVERRIDE", IDL_SYMBOL_OVERRIDE, KIND_UNKNOWN},
+  {"NOMREGISTEREDIFACE", IDL_SYMBOL_REGINTERFACE, KIND_TYPESPEC},
+  {"native", IDL_SYMBOL_NATIVE, KIND_UNKNOWN},
   {"gulong", IDL_SYMBOL_GULONG, KIND_TYPESPEC},
   {"gint", IDL_SYMBOL_GINT, KIND_TYPESPEC},
   {"gpointer", IDL_SYMBOL_GPOINTER, KIND_TYPESPEC},
   {"gboolean", IDL_SYMBOL_GBOOLEAN, KIND_TYPESPEC},
+  {"gchar", IDL_SYMBOL_GCHAR, KIND_TYPESPEC},
+  {"void", IDL_SYMBOL_VOID, KIND_TYPESPEC},
   {"in", IDL_SYMBOL_IN, KIND_DIRECTION},
   {"out", IDL_SYMBOL_OUT, KIND_DIRECTION},
@@ -155 +159 @@
 }
 
+/*
+  The native keyword is used to introduce new types. That's coming
+  from the Corba spec. Maybe we will change that some time.
+
+The current token is the 'native' keyword.
+
+  N:= G_TOKEN_SYMBOL IDENT ';'
+ */
+static void parseNative(void)
+{
+  GTokenValue value;
+  PSYMBOL pCurSymbol=g_malloc0(sizeof(SYMBOL));
+
+  if(!matchNext(G_TOKEN_IDENTIFIER))
+    {
+      PSYMBOL pSymbol;
+
+      /* Check if it's a symbol. The following 'identifier' (word) is maybe alread
+       registered as a symbol. */
+      if(!matchNext(G_TOKEN_SYMBOL))
+        {
+          g_scanner_unexp_token(gScanner,
+                                G_TOKEN_SYMBOL,
+                                NULL,
+                                NULL,
+                                NULL,
+                                "'native' statement is not followed by a valid identifier.",
+                                TRUE); /* is_error */
+          exit(1);
+        }
+      /* It's a symbol. Check if it's a typespec. */
+      value=gScanner->value;
+      pSymbol=value.v_symbol;
+      if(!pSymbol || pSymbol->uiKind!=KIND_TYPESPEC)
+        {
+          g_scanner_unexp_token(gScanner,
+                                G_TOKEN_SYMBOL,
+                                NULL,
+                                NULL,
+                                NULL,
+                                "'native' statement is not followed by a valid symbol.",
+                                TRUE); /* is_error */
+          exit(1);
+        }
+    }
+
+    value=gScanner->value;
+    pCurSymbol->chrSymbolName=g_strdup(value.v_identifier);
+    pCurSymbol->uiKind=KIND_TYPESPEC;
+    pCurSymbol->uiSymbolToken=G_TOKEN_NONE;
+    g_tree_insert(parseInfo.pSymbolTree, pCurSymbol, pCurSymbol->chrSymbolName);
+    g_scanner_scope_add_symbol(gScanner, ID_SCOPE, pCurSymbol->chrSymbolName,
+                             pCurSymbol);
+
+    if(!matchNext(';'))
+      {
+        getNextToken(); /* Make sure error references the correct token */
+        g_scanner_unexp_token(gScanner,
+                              ';',
+                              NULL,
+                              NULL,
+                              NULL,
+                              "Error in 'native' definition , Missing semicolon",
+                              TRUE); /* is_error */
+        exit(1);
+      }
+
+}
 
 /**
@@ -180 +252 @@
             case IDL_SYMBOL_INTERFACE:
               parseInterface(token);
+              break;
+            case IDL_SYMBOL_NATIVE:
+              parseNative();
               break;
             default:
@@ -226 +301 @@
       default:
         printToken(curToken);
-        //  g_message("Token: %d (---)\t\t\t%c (LINE %d)", token, token, g_scanner_cur_line(gScanner));
         break;
       }
@@ -246 +320 @@
 }
 
+/*
+  Compare function for the tree holding our private symbols.
+ */
 static gint funcSymbolCompare(gconstpointer a, gconstpointer b)
 {
@@ -256 +333 @@
   return 1;
 };
+
+void funcMsgHandler(GScanner *gScanner,
+                    gchar *message,
+                    gboolean error)
+{
+
+  g_printf("In file %s, line %d:\n\t%s\n", parseInfo.chrCurrentSourceFile,
+           g_scanner_cur_line(gScanner)-parseInfo.uiLineCorrection, message);
+}
+
 /*
 
@@ -263 +350 @@
   int a;
   int fd;
-  int idScope=0;
+
   GError *gError = NULL;
   GOptionContext* gContext;
@@ -310 +397 @@
 
   /* Create output file name */
-
-  fd=open(argv[1], O_RDONLY);
+  if(!strcmp(argv[1], "-"))
+    fd=0; /* Read from stdin */
+  else
+    fd=open(argv[1], O_RDONLY);
   
   if(-1==fd)
@@ -327 +416 @@
   curSymbol.pSymbols=idlSymbols;
 
+  gScanner->msg_handler=funcMsgHandler;
   pInterfaceArray=g_ptr_array_new();
 
@@ -336 +426 @@
   gScanner->input_name=IDL_COMPILER_STRING;
 
-  g_scanner_set_scope(gScanner, idScope);
+  g_scanner_set_scope(gScanner, ID_SCOPE);
   /* Load our own symbols into the scanner. We use the default scope for now. */
   parseInfo.pSymbolTree=g_tree_new((GCompareFunc) funcSymbolCompare);
   while(pSymbols->chrSymbolName)
     {
-      g_scanner_scope_add_symbol(gScanner, idScope, pSymbols->chrSymbolName,
+#warning !!! Create a copy here so it is the same as with new symbols added later.
+      g_scanner_scope_add_symbol(gScanner, ID_SCOPE, pSymbols->chrSymbolName,
                                  pSymbols);
       g_tree_insert(parseInfo.pSymbolTree, pSymbols, pSymbols->chrSymbolName);
@@ -371 +462 @@
 
 #endif
+
+
+
+
+
+
+
+
+

trunk/idl-compiler/include/parser.h

@@ -46 +46 @@
 
 #define IDL_COMPILER_STRING "IDL compiler" /* Used inside warnings and errors */
+#define ID_SCOPE 0
 
 /* Holding an overriden method */
@@ -127 +128 @@
   IDL_SYMBOL_INSTANCEVAR,
   IDL_SYMBOL_OVERRIDE,
+  IDL_SYMBOL_REGINTERFACE,  /* Used for registered interfaces */
+  IDL_SYMBOL_NATIVE,
   /* Some GLib types */
   IDL_SYMBOL_GULONG,           /* 275 */
@@ -132 +135 @@
   IDL_SYMBOL_GPOINTER,
   IDL_SYMBOL_GBOOLEAN,
+  IDL_SYMBOL_GCHAR,
+  IDL_SYMBOL_VOID,
   /* Direction of method parameters */
   IDL_SYMBOL_IN,

trunk/idl-compiler/parser_c/interface_parser.c

@@ -45 +45 @@
 /* The pointer array holding the interfaces we found */
 extern GPtrArray* pInterfaceArray;
-
+extern PARSEINFO parseInfo;
+
+static void registerInterface(void)
+{
+  PSYMBOL pNewSymbol=g_malloc0(sizeof(SYMBOL));
+
+  g_ptr_array_add(pInterfaceArray, (gpointer) pCurInterface);
+
+  /* Any found interface is registered as a new type so it can be
+     used in other classes. */
+  pNewSymbol->chrSymbolName=g_strdup(pCurInterface->chrName); /* We create a copy here because
+                                                                 when cleaning up the symbol space
+                                                                 the string will be freed. */
+  pNewSymbol->uiKind=KIND_TYPESPEC;
+  pNewSymbol->uiSymbolToken=IDL_SYMBOL_REGINTERFACE;
+  g_tree_insert(parseInfo.pSymbolTree, pNewSymbol, pNewSymbol->chrSymbolName);
+  g_scanner_scope_add_symbol(gScanner, ID_SCOPE, pNewSymbol->chrSymbolName,
+                             pNewSymbol);
+}
 
 static PINTERFACE createInterfaceStruct()
@@ -178 +196 @@
   interface is already defined.
 
-  IS:= G_TOKEN_INDENTIFIER IB2
+  IS:= G_TOKEN_SYMBOL IB2
+
+  It's G_TOKEN_SYMBOL here because every found interface is registered
+  as a new symbol with GScanner.
  */
 static void parseSubclassedIFace()
 {
+  PSYMBOL pCurSymbol;
 
   /* Parent interface */
-  if(!matchNext(G_TOKEN_IDENTIFIER))
-    {
-      g_scanner_unexp_token(gScanner,
-                            G_TOKEN_IDENTIFIER,
-                            NULL,
-                            NULL,
-                            NULL,
-                            "Parent interface name is missing.",
+  if(!matchNext(G_TOKEN_SYMBOL))
+    {
+      g_scanner_unexp_token(gScanner,
+                            G_TOKEN_SYMBOL,
+                            NULL,
+                            NULL,
+                            NULL,
+                            "Parent interface name is missing or unknown.",
                             TRUE); /* is_error */
       exit(1);
     }
   GTokenValue value=gScanner->value;
-  pCurInterface->chrParent=g_strdup(value.v_identifier);
+  /* Make sure it's the correct symbol */
+  pCurSymbol=value.v_symbol;
+
+  if(IDL_SYMBOL_REGINTERFACE!=pCurSymbol->uiSymbolToken)
+    {
+      g_scanner_unexp_token(gScanner,
+                            G_TOKEN_SYMBOL,
+                            NULL,
+                            NULL,
+                            NULL,
+                            "Parent interface name is unknown.",
+                            TRUE); /* is_error */
+      exit(1);
+    }
+  pCurInterface->chrParent=g_strdup(pCurSymbol->chrSymbolName);
 
   /* Check if the parent interface is known. */
@@ -209 +245 @@
                           TRUE); /* is_error */
     exit(1);
-
   }
 
@@ -238 +273 @@
   interface:= I ';'                       // Forward declaration
             | I '{' IB '}'
-            | I ':' G_TOKEN_INDENTIFIER '{' IB '}'
+            | I ':' G_TOKEN_SYMBOL '{' IB '}'
+
+            It's G_TOKEN_SYMBOL here because every found interface is registered
+            as a new symbol with GScanner.
  */
 void parseInterface(GTokenType token)
@@ -246 +284 @@
   /* Get the interface name */
   parseIFace(token);
+  /* It's save to register the interface right here even if the struct is almost empty. 
+     If anything goes wrong later we will exit anyway. */
+  registerInterface();  
 
   if(matchNext(';'))
     {
       pCurInterface->fIsForwardDeclaration=TRUE;
-      g_ptr_array_add(pInterfaceArray, (gpointer) pCurInterface);
-
     }
   else if(matchNext(':'))
     {
       parseSubclassedIFace();
-      g_ptr_array_add(pInterfaceArray, (gpointer) pCurInterface);
     }
   else if(matchNext('{'))
     {
       parseIFaceBody();
-      g_ptr_array_add(pInterfaceArray, (gpointer) pCurInterface);
     }
   else

trunk/idl-compiler/parser_c/lineinfo_parser.c

@@ -40 +40 @@
 
 extern GScanner *gScanner;
- 
+extern PARSEINFO parseInfo;
 
 /*
@@ -50 +50 @@
 {
   GTokenValue value;
-  PSYMBOLINFO psi=(PSYMBOLINFO)gScanner->user_data;
 
   /* Line number */
   value=gScanner->value;
-  psi->uiLineCorrection=value.v_int;
+  parseInfo.uiLineCorrection=g_scanner_cur_line(gScanner)-value.v_int+1;
 
   if(!matchNext(G_TOKEN_STRING))
@@ -70 +69 @@
 
   /* Current source file */
-  if(psi->chrCurrentSourceFile)
-    g_free(psi->chrCurrentSourceFile);
+  if(parseInfo.chrCurrentSourceFile)
+    g_free(parseInfo.chrCurrentSourceFile);
 
   value=gScanner->value;
-  psi->chrCurrentSourceFile=g_strdup(value.v_string);
+  parseInfo.chrCurrentSourceFile=g_strdup(value.v_string);
 
   /* Trailing file include level info isn't used for now. Note that for the root