%X => %_X, %_X => %__X

src/parser.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 4604 matching lines @@
     // very first time not when reparsing because of lazy compilation.
     top_scope_->DeclarationScope()->ForceEagerCompilation();
   }
 
   const Runtime::Function* function = Runtime::FunctionForSymbol(name);
 
   // Check for built-in IS_VAR macro.
   if (function != NULL &&
       function->intrinsic_type == Runtime::RUNTIME &&
       function->function_id == Runtime::kIS_VAR) {
     // %IS_VAR(x) evaluates to x if x is a variable,

[Michael Starzinger, 2013/01/31 15:04:53]

Comment about IS_VAR needs adaptation as well.

[drcarney, 2013/01/31 15:20:48]

This gets handled by the automatic replace

     // leads to a parse error otherwise.  Could be implemented as an
     // inline function %_IS_VAR(x) to eliminate this special case.
     if (args->length() == 1 && args->at(0)->AsVariableProxy() != NULL) {
       return args->at(0);
     } else {
       ReportMessage("unable_to_parse", Vector<const char*>::empty());
       *ok = false;
       return NULL;
     }
   }
 
   // Check that the expected number of arguments are being passed.
   if (function != NULL &&
       function->nargs != -1 &&
       function->nargs != args->length()) {
     ReportMessage("illegal_access", Vector<const char*>::empty());
     *ok = false;
     return NULL;
   }
 
-  // Check that the function is defined if it's an inline runtime call.
-  if (function == NULL && name->Get(0) == '_') {
-    ReportMessage("not_defined", Vector<Handle<String> >(&name, 1));
-    *ok = false;
-    return NULL;
+  if (function == NULL && name->length() > 0 && name->Get(0) == '_') {
+    // Check that the function is defined if it's an inline runtime call.
+    if (name->length() > 1 && name->Get(1) == '_') {
+      ReportMessage("not_defined", Vector<Handle<String> >(&name, 1));
+      *ok = false;
+      return NULL;
+    }
+    // Assume this is a runtime-js function called via %_name.
+    name = isolate()->factory()->NewSubString(name, 1, name->length());

[Michael Starzinger, 2013/01/31 15:04:53]

This essentially merge the "%foo" and "%_foo" namespace at the moment, which is
probably not what we want. Instead the "%foo" namespace should be checked
against a white-list of allowed API-instrinsics. That white-list is empty for
now.

Also the AST node generated at the end of this function needs to know the
distinction between API-intrinsics and runtime-intrinsics, because otherwise
that distinction would be lost by the name mangling.

[drcarney, 2013/01/31 15:20:48]

Yes, I was planning this for the patch that actually introduces the public
intrinsics.

+    name = isolate()->factory()->LookupSymbol(name);
   }
 
   // We have a valid intrinsics call or a call to a builtin.
   return factory()->NewCallRuntime(name, function, args);
 }
 
 
 bool Parser::peek_any_identifier() {
   Token::Value next = peek();
   return next == Token::IDENTIFIER ||
@@ skipping 1268 matching lines @@
       ASSERT(info->isolate()->has_pending_exception());
     } else {
       result = parser.ParseProgram();
     }
   }
   info->SetFunction(result);
   return (result != NULL);
 }
 
 } }  // namespace v8::internal