• 2827:   rv = systemCertZip->Open(systemCertFile);

• 135:  JMESSAGE(JTRC_EMS_OPEN, "Obtained EMS handle %u")
• 161:  JMESSAGE(JTRC_TFILE_OPEN, "Opened temporary file %s")
• 171:  JMESSAGE(JTRC_XMS_OPEN, "Obtained XMS handle %u")

• 934:  /* Caller is responsible for opening the file before and closing after. */

• 155:  #ifdef DONT_USE_B_MODE /* define mode parameters for fopen() */

• 30:  #define jpeg_open_backing_store jOpenBackStore
• 173:   * Initial opening of a backing-store object. This must fill in the
• 180:  EXTERN(void) jpeg_open_backing_store JPP((j_common_ptr cinfo,
• 194:   * all opened backing-store objects have been closed.

• 731:   // document.open/write/close(), ignore it.

• 125:   nsresult GetTopEnclosingPre(nsIDOMNode *aNode, nsIDOMNode** aOutPreNode);

• 947:  // while the batch is open. The advantage of this is that
• 2245:   *aState |= nsIContent::IME_STATUS_OPEN;

• 276:   nsresult GetTopEnclosingMailCite(nsIDOMNode *aNode, nsCOMPtr<nsIDOMNode> *aOutCiteNode, PRBool aPlaintext);

• 74:  /* Here is how to open a channel for testing
• 83:   rv = NS_OpenURI(getter_AddRefs(theChannel), theURI, nsnull, theLoadGroup);
• 94:   rv = theChannel->AsyncOpen(listener, nsnull);

• 347:   friend class nsHTMLEditRules; // opening this class up for pillaging
• 348:   friend class nsHTMLEditor; // opening this class up for more pillaging

• 1800:   res = GetTopEnclosingMailCite(selNode, address_of(citeNode), aPlaintext);
• 2379:   res = GetTopEnclosingMailCite(startNode, address_of(startCiteNode),
• 2382:   res = GetTopEnclosingMailCite(endNode, address_of(endCiteNode),
• 2975:   res = GetTopEnclosingMailCite(startNode, address_of(citeNode),
• 5741:   nsCOMPtr<nsIDOMNode> opEndNode;
• 5742:   PRInt32 opStartOffset, opEndOffset;
• 5747:   res = GetPromotedPoint( kEnd, endNode, endOffset, inOperationType, address_of(opEndNode), &opEndOffset);
• 5751:   res = inRange->SetEnd(opEndNode, opEndOffset);
• 7317:  nsHTMLEditRules::GetTopEnclosingMailCite(nsIDOMNode *aNode,

• 49:   * * open of document (once rendered in window but before editable)
• 56:   * for transaction purposes (undo/redo) except for the open event.
• 64:   * Note: If cancellation occurs during the "open" event, the editor will

• 72:   (void)ss->OpenSpecialDatabase("memory", getter_AddRefs(conn));

• 64:   case SQLITE_CANTOPEN:

• 297:   NS_ASSERTION (!mDBConn, "Initialize called on already opened database!");
• 313:   srv = ::sqlite3_open(NS_ConvertUTF16toUTF8(path).get(), &mDBConn);
• 317:   srv = ::sqlite3_open(":memory:", &mDBConn);
• 333:   PR_LOG(gStorageLog, PR_LOG_NOTICE, ("Opening connection to '%s' (%p)",
• 343:   // Execute a dummy statement to force the db open, and to verify if it is
• 471:   PR_LOG(gStorageLog, PR_LOG_NOTICE, ("Opening connection to '%s'",

• 76:   * The nsIFile of the location of the database to open, or create if it

• 153:   // various sqlite3 functions (and the sqlite3_open calls in our case),
• 188:  Service::OpenSpecialDatabase(const char *aStorageKey,
• 224:  Service::OpenDatabase(nsIFile *aDatabaseFile,
• 241:  Service::OpenUnsharedDatabase(nsIFile *aDatabaseFile,
• 249:   // caches when they are opened, and they retain those caches for their

• 49:   * This is the only way to open a database connection.
• 59:   * @see openDatabase for restrictions on how database connections may be
• 68:   mozIStorageConnection openSpecialDatabase(in string aStorageKey);
• 71:   * Open a connection to the specified file.
• 84:   * a simple string compare to see if there is already a connection. Opening
• 91:   * must open it with openUnsharedDatabase, as those tables are incompatible
• 92:   * with a shared cache. If you attempt to use this method to open a database
• 97:   * A nsIFile that represents the database that is to be opened..
• 106:   mozIStorageConnection openDatabase(in nsIFile aDatabaseFile);
• 109:   * Open a connection to the specified file that doesn't share a sqlite cache.
• 112:   * should use openDatabase instead of this method unless you need a feature
• 127:   * a simple string compare to see if there is already a connection. Opening
• 134:   * A nsIFile that represents the database that is to be opened..
• 143:   mozIStorageConnection openUnsharedDatabase(in nsIFile aDatabaseFile);

• 112:   * Unable to open the database file.
• 114:   const long CANTOPEN = 14;
• 162:   * File opened that is not a database file.

• 74:   * Indicates if the connection is open and ready to use. This will be false
• 75:   * if the connection failed to open, or it has been closed.

• 1051:   rv = channel->AsyncOpen(httpIndex, aSource);
• 1407:   // and open the directory viewer XUL file as the content stream to
• 1437:   rv = channel->AsyncOpen(listener, nsnull);

• 170:   OnOpenWindow(window);
• 204:  /* void onOpenWindow (in nsIXULWindow window); */
• 206:  nsWindowDataSource::OnOpenWindow(nsIXULWindow *window)

• 68:  static PRBool notifyOpenWindow(nsISupports *aElement, void* aData);
• 128:   mListeners->EnumerateForwards(notifyOpenWindow, (void*)&winData);
• 783:  notifyOpenWindow(nsISupports *aElement, void* aData)
• 788:   listener->OnOpenWindow(winData->mWindow);

• 253:   for fear it could hide newly opened browser windows */
• 558:   script, anything could happen. A new window could open, even.
• 575:   the window is being opened. but it should probably just always be so. */
• 593:   the window is being opened. but it should probably just always be so. */
• 614:   the window is being opened. but it should probably just always be so. */
• 1233:   the entire list of open windows until it finds a non-collision. Doesn't
• 1763:   if (aChromeFlags & nsIWebBrowserChrome::CHROME_OPENAS_CHROME)
• 1813:   // and allow the opening code to proceed.

• 858:   // Where should we open this?
• 860:   if (NS_FAILED(branch->GetIntPref("open_newwindow", &containerPref))) {
• 864:   if (containerPref != nsIBrowserDOMWindow::OPEN_NEWTAB &&
• 865:   containerPref != nsIBrowserDOMWindow::OPEN_CURRENTWINDOW) {
• 866:   // Just open a window normally
• 873:   1: don't divert window.open at all
• 874:   2: don't divert window.open with features
• 877:   if (NS_FAILED(branch->GetIntPref("open_newwindow.restriction",
• 911:   *aWindowIsNew = (containerPref != nsIBrowserDOMWindow::OPEN_CURRENTWINDOW);
• 918:   return browserDOMWin->OpenURI(nsnull, aParent, containerPref,
• 919:   nsIBrowserDOMWindow::OPEN_NEW, aReturn);

• 346:   // an alwaysRaised (or higher) window will hide any newly opened

• 306:   widgetInitData.mWindowType = aChromeMask & nsIWebBrowserChrome::CHROME_OPENAS_DIALOG ?
• 314:   // Adding CHROME_OPENAS_CHROME to sheetMask makes modal windows opened from
• 316:   // windows opened from nsPromptService::DoDialog() still are sheets. This
• 319:   PRUint32 sheetMask = nsIWebBrowserChrome::CHROME_OPENAS_DIALOG |
• 321:   nsIWebBrowserChrome::CHROME_OPENAS_CHROME;
• 345:   if (!(aChromeMask & nsIWebBrowserChrome::CHROME_OPENAS_DIALOG))
• 349:   if (!(aChromeMask & nsIWebBrowserChrome::CHROME_OPENAS_DIALOG))
• 492:   // an ongoing attempt to quit is stopped by a newly opened window

• 48:   void onOpenWindow(in nsIXULWindow window);

• 104:   * addListener) will be notified through their onOpenWindow method.

• 105:   * if you'd like to subsequently call OpenDialog on the hidden window.

• 1:  /* Copyright (c) 1998, 1999, 2000 Thai Open Source Software Center Ltd

• 1:  /* Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
• 35:  #define XML_TOK_CDATA_SECT_OPEN 8
• 49:  #define XML_TOK_DECL_OPEN 16 /* <!foo */
• 56:  #define XML_TOK_OPEN_PAREN 23
• 58:  #define XML_TOK_OPEN_BRACKET 25
• 68:  #define XML_TOK_COND_SECT_OPEN 33 /* <![ */

• 1:  /* Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd

• 1:  /* Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd

• 1:  /* Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
• 66:   XML_ROLE_GROUP_OPEN,

• 1:  /* Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd

• 1:  /* Copyright (c) 1998, 1999, 2000 Thai Open Source Software Center Ltd
• 838:   of a name specifies that the general entity of the name is open; a
• 1009:  /* BEGIN MOZILLA CHANGE (Report opening tag of mismatched closing tag) */

• 1:  /* Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd

• 1:  /* Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd

• 2:  Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd

• 82:   * the open container hierarchy. If a style tag(s) fails to be closed when a normal
• 92:   * child container is opened.
• 152:   * @param aTag The actual tag that is being opened (should correspond to
• 157:   nsresult OpenContainer(const nsCParserNode *aNode,
• 221:   * the current context vector stack. And actually open the required tags.
• 223:   * @param aParent The tag we're trying to open this element inside of.
• 229:   * Ask if a given container is open anywhere on its stack
• 232:   * @return TRUE if the given container type is open -- otherwise FALSE
• 234:   PRBool HasOpenContainer(eHTMLTags aContainer) const;
• 238:   * in a set of tags is currently open.
• 241:   * @return PR_TRUE if any of the members of aTagSet are currently open.
• 243:   PRBool HasOpenContainer(const eHTMLTags aTagSet[], PRInt32 aCount) const;
• 300:   nsresult OpenHTML(const nsCParserNode *aNode);
• 301:   nsresult OpenBody(const nsCParserNode *aNode);
• 305:   * one or more open containers.
• 331:   nsresult OpenTransientStyles(eHTMLTags aChildTag,
• 405:   PRInt32 mOpenMapCount;

• 1793:   * Open up the parser for tokenization, building up content
• 2133:   dtd->OpenContainer(&bodyNode, eHTMLTag_body);
• 2747:   // skip open quote

• 123:   nsTagEntry* PopEntry();
• 189:   table that is opened on the stack. As tables open and
• 204:   PRBool CanOpenCaption() {
• 209:   PRBool CanOpenCols() {
• 214:   PRBool CanOpenTBody() {
• 219:   PRBool CanOpenTHead() {
• 224:   PRBool CanOpenTFoot() {
• 309:   nsTagEntry* PopEntry();
• 322:   PRBool HasOpenContainer(eHTMLTags aTag) const;

• 56:   it originated. A node with an mParent of 0 is not opened on tag stack,
• 57:   but is open on stylestack.
• 269:   // This tells us that the style is not open at any level.
• 289:   * stack since it's no longer open.
• 316:   // This tells us that the style is not open at any level
• 419:  nsEntryStack::PopEntry()
• 479:  PRBool nsDTDContext::HasOpenContainer(eHTMLTags aTag) const {
• 514:  nsDTDContext::PopEntry()
• 522:   return mStack.PopEntry();
• 687:   theEntry->mParent=0; //this tells us that the style is not open at any level

• 200:   const XML_Char *aOpenEntityNames,
• 213:   return driver->HandleExternalEntityRef(aOpenEntityNames, aBase, aSystemId,
• 720:  nsExpatDriver::HandleExternalEntityRef(const PRUnichar *openEntityNames,
• 725:   if (mInInternalSubset && !mInExternalDTD && openEntityNames) {
• 727:   mInternalSubset.Append(nsDependentString(openEntityNames));
• 734:   nsresult rv = OpenInputStreamFromExternalDTD(publicId, systemId, base,
• 770:  nsExpatDriver::OpenInputStreamFromExternalDTD(const PRUnichar* aFPIStr,
• 824:   rv = NS_OpenURI(aStream, uri);

• 93:  // just get dropped automatically, since they are not allowed to open inside
• 94:  // <select>. Note that we are NOT allowing them to actually open without
• 748:   /*special props, prop-range*/ kNonContainer|kPreferHead|kLegalOpen,kDefaultPropRange,
• 946:   /*special props, prop-range*/ kNoStyleLeaksIn|kLegalOpen, kNoPropRange,
• 1028:   /*special props, prop-range*/ kNoStyleLeaksIn|kPreferHead|kLegalOpen, kNoPropRange,
• 1215:   /*special props, prop-range*/ kNonContainer|kLegalOpen,kNoPropRange,
• 1228:   /*special props, prop-range*/ kNonContainer|kLegalOpen, kNoPropRange,
• 1241:   /*special props, prop-range*/ kOmitEndTag|kLegalOpen,kNoPropRange,
• 1308:   * @param aTagStack -- list of open tags
• 1500:   * Tells us whether the given tag opens a section
• 1503:   * @return TRUE if opens section
• 1544:   if(gHTMLElements[aChild].HasSpecialProperty(kLegalOpen)) {
• 1545:   // Some tags could be opened anywhere, in the document, as they please.
• 2046:   if(gHTMLElements[aChild].HasSpecialProperty(kLegalOpen)) {
• 2047:   // Some tags could be opened anywhere, in the document, as they please.

• 231:   mHasOpenRoot=PR_FALSE;
• 232:   mHasOpenBody=PR_FALSE;
• 237:   gDumpFile = fopen(gDumpFileName,"w");
• 350:   if(!mHasOpenRoot) {
• 355:   mSink->OpenContainer(htmlNode);
• 359:   mSink->OpenContainer(headNode);
• 363:   mSink->OpenContainer(titleNode);
• 409:   mHasOpenRoot = PR_TRUE;
• 412:   if (NS_SUCCEEDED(result) && !mHasOpenBody) {
• 431:   result = mSink->OpenContainer(bodyNode);
• 432:   if(NS_SUCCEEDED(result)) mHasOpenBody=PR_TRUE;
• 447:   result = mSink->OpenContainer(preNode);
• 507:   mSink->OpenContainer(startNode);
• 553:   //ADD CODE HERE TO CLOSE OPEN CONTAINERS...
• 562:   //now let's close automatically auto-opened containers...
• 763:   mSink->OpenContainer(mErrorNode);
• 794:   mSink->OpenContainer(mStartNode); //emit <starttag>...
• 1101:   PRBool openingExecutesScript = PR_FALSE;
• 1102:   rv = NS_URIChainHasFlags(hrefURI, nsIProtocolHandler::URI_OPENING_EXECUTES_SCRIPT,
• 1103:   &openingExecutesScript);
• 1105:   if (openingExecutesScript) {
• 1146:   // Open the element, supplying the attribute, if any.
• 1163:   mSink->OpenContainer(startNode);
• 1197:   // start..end is half-open. That means the last character of the interval is

• 290:   // ready to Consume the rest of the open tag identifier.
• 1303:   // If beginData == end, we did not find opening '--'

• 173:  nsLoggingSink::OpenContainer(const nsIParserNode& aNode) {
• 175:   OpenNode("container", aNode); //do the real logging work...
• 181:   theResult=mSink->OpenContainer(aNode);
• 302:  nsLoggingSink::OpenHead() {
• 304:   PR_fprintf(mOutput,"<open container=head>\n");
• 310:   theResult=mSink->OpenHead();
• 317:  nsLoggingSink::OpenNode(const char* aKind, const nsIParserNode& aNode) {
• 320:   PR_fprintf(mOutput,"<open container=");
• 340:   PR_fprintf(mOutput, "</open>\n");

• 144:   PRPackedBool mHasOpenRoot;
• 145:   PRPackedBool mHasOpenBody;

• 67:   int HandleExternalEntityRef(const PRUnichar *aOpenEntityNames,
• 103:   nsresult OpenInputStreamFromExternalDTD(const PRUnichar* aFPIStr,

• 69:   NS_IMETHOD OpenContainer(const nsIParserNode& aNode);
• 80:   NS_IMETHOD OpenHead();
• 96:   nsresult OpenNode(const char* aKind, const nsIParserNode& aNode);

• 99:  #define NS_DTD_FLAG_HAS_OPEN_HEAD 0x00000001
• 100:  #define NS_DTD_FLAG_HAS_OPEN_BODY 0x00000002
• 101:  #define NS_DTD_FLAG_HAS_OPEN_FORM 0x00000004
• 135:   mOpenMapCount(0),
• 165:   // Open the record file.
• 166:   PRFileDesc *theLogFile = PR_Open(gLogPath, theFlags, 0);
• 290:   // Always open a body if frames are disabled.
• 301:   // If the content model is empty, then begin by opening <html>.
• 484:   * @return PR_TRUE if aToken does indeed force the body to open.
• 495:   // IE & Nav4x opens up a body for type=text - Bug 66985
• 496:   // XXXbz but we don't want to open one for <input> with no
• 573:   * Returns whether or not there is a tag of type aType open on aContext.
• 576:  HasOpenTagOfType(PRInt32 aType, const nsDTDContext& aContext)
• 634:   (!gHTMLElements[theTag].HasSpecialProperty(kLegalOpen) ||
• 673:   // At this point we know the body/frameset aren't open.
• 674:   // If the child belongs in the head, then handle it (which may open
• 687:   // there is no indication that the body should be open,
• 693:   // "open", so push this token onto the misplaced content stack.
• 703:   // Some tags (such as <object> and <script>) are opened in the
• 718:   // contents would force us to open a body, which could be
• 986:   theChildAgrees = HasOpenContainer(theAncestor);
• 1018:   * an open <A> above <B>..so that the inner <A> can close
• 1067:   // Break out of this loop and open the block.
• 1078:   result = OpenContainer(aNode, aChildTag);
• 1107:   * too deep) I've also opened this up to any container (not just inlines):
• 1173:   if (mFlags & NS_DTD_FLAG_HAS_OPEN_HEAD) {
• 1343:   result = OpenContainer(theNode, theChildTag);
• 1349:   if (mFlags & NS_DTD_FLAG_HAS_OPEN_BODY) {
• 1350:   result = OpenContainer(theNode, theChildTag);
• 1374:   if (!mOpenMapCount) {
• 1381:   if (mOpenMapCount > 0 && mSink) {
• 1415:   // body have been explicitly opened) then check that we haven't seen the
• 1417:   // check if the head has been explicitly opened. See bug 307122.
• 1422:  _FLAG_HAS_OPEN_HEAD)
• 1610:   * have a close tag with no prior open tag (user error) or because
• 1668:   // CloseContainersTo() has the bad habit of closing tags that are opened
• 1692:   // First open transient styles, so that we see any autoclosed style
• 1695:   result = OpenTransientStyles(theChildTag);
• 1721:   // If the bit kHandleStrayTag is set then we automatically open up a
• 1880:   // CloseContainersTo does not close any forms we might have opened while
• 2153:   HasOpenContainer(eHTMLTag_nobr)) {
• 2256:   * tag can be omitted from opening. Most cannot.
• 2267:   if (eHTMLTag_unknown != theAncestor && HasOpenContainer(theAncestor)) {
• 2273:   // If there's a required ancestor, we only omit if it isn't open and we
• 2275:   return !HasOpenContainer(theAncestor) &&
• 2382:  PRBool CNavDTD::HasOpenContainer(eHTMLTags aContainer) const
• 2386:   return !(~mFlags & NS_DTD_FLAG_HAS_OPEN_FORM);
• 2388:   return mOpenMapCount > 0;
• 2390:   return mBodyContext->HasOpenContainer(aContainer);
• 2395:  CNavDTD::HasOpenContainer(const eHTMLTags aTagSet[], PRInt32 aCount) const
• 2417:   * The gets called whenever a container gets opened. This methods job is to
• 2418:   * take a look at the (transient) style stack, and open any style containers that
• 2419:   * are there. Of course, we shouldn't bother to open styles that are incompatible
• 2423:   * @param tag of the container just opened
• 2427:  CNavDTD::OpenTransientStyles(eHTMLTags aChildTag, PRBool aCloseInvalid)
• 2431:   // No need to open transient styles in head context - Fix for 41427
• 2434:   !(mFlags & NS_DTD_FLAG_HAS_OPEN_HEAD)) {
• 2452:   // Don't open transient styles if it makes the stack deep, bug 58917.
• 2460:   PRBool isHeadingOpen = HasOpenTagOfType(kHeading, *mBodyContext);
• 2470:   if (isHeadingOpen) {
• 2480:   result = OpenContainer(theNode, theNodeTag, theStack);
• 2483:   result = OpenContainer(theNode, theNodeTag, theStack);
• 2532:  CNavDTD::OpenHTML(const nsCParserNode *aNode)
• 2537:   MOZ_TIMER_DEBUGLOG(("Stop: Parse Time: CNavDTD::OpenHTML(), this=%p\n", this));
• 2539:   nsresult result = mSink ? mSink->OpenContainer(*aNode) : NS_OK;
• 2541:   MOZ_TIMER_DEBUGLOG(("Start: Parse Time: CNavDTD::OpenHTML(), this=%p\n", this));
• 2561:  CNavDTD::OpenBody(const nsCParserNode *aNode)
• 2571:   MOZ_TIMER_DEBUGLOG(("Stop: Parse Time: CNavDTD::OpenBody(), this=%p\n", this));
• 2573:   // Make sure the head is closed by the time the body is opened.
• 2576:   // Now we can open the body.
• 2577:   result = mSink ? mSink->OpenContainer(*aNode) : NS_OK;
• 2579:   MOZ_TIMER_DEBUGLOG(("Start: Parse Time: CNavDTD::OpenBody(), this=%p\n", this));
• 2582:   if (!HasOpenContainer(eHTMLTag_body)) {
• 2597:   * @param aClosedByStartTag -- ONLY TRUE if the container is being closed by opening of another container.
• 2601:  CNavDTD::OpenContainer(const nsCParserNode *aNode,
• 2610:   // We need to open transient styles to encompass the <li> so that the bullets
• 2618:   * If there's an <a> on the RS-stack, and you're trying to open
• 2621:   * I'm updating OpenTransientStyles to throw old <a>'s away.
• 2623:   OpenTransientStyles(aTag, !li_tag);
• 2628:   result = OpenHTML(aNode);
• 2632:   if (!(mFlags & NS_DTD_FLAG_HAS_OPEN_HEAD)) {
• 2633:   mFlags |= NS_DTD_FLAG_HAS_OPEN_HEAD;
• 2642:   mFlags |= NS_DTD_FLAG_HAS_OPEN_BODY;
• 2643:   result = OpenBody(aNode);
• 2651:   ++mOpenMapCount;
• 2657:   if (!(mFlags & NS_DTD_FLAG_HAS_OPEN_FORM)) {
• 2658:   mFlags |= NS_DTD_FLAG_HAS_OPEN_FORM;
• 2659:   result = mSink ? mSink->OpenContainer(*aNode) : NS_OK;
• 2664:   // Make sure that the head is closed before we try to open this frameset.
• 2667:   // Now that the head is closed, continue on with opening this frameset.
• 2679:   // We want to make sure that OpenContainer gets called below since we're
• 2705:   MOZ_TIMER_DEBUGLOG(("Stop: Parse Time: CNavDTD::OpenContainer(), this=%p\n", this));
• 2707:   result = mSink ? mSink->OpenContainer(*aNode) : NS_OK;
• 2709:   MOZ_TIMER_DEBUGLOG(("Start: Parse Time: CNavDTD::OpenContainer(), this=%p\n", this));
• 2749:   if (mFlags & NS_DTD_FLAG_HAS_OPEN_HEAD) {
• 2750:   mFlags &= ~NS_DTD_FLAG_HAS_OPEN_HEAD;
• 2765:   if (mOpenMapCount) {
• 2766:   mOpenMapCount--;
• 2772:   if (mFlags & NS_DTD_FLAG_HAS_OPEN_FORM) {
• 2773:   mFlags &= ~NS_DTD_FLAG_HAS_OPEN_FORM;
• 2897:   * caused by a close tag (as opposed to an open tag).
• 2981:   * @param aClosedByStartTag -- ONLY TRUE if the container is being closed by opening of another container.
• 2992:   // The tag is indeed open, so close it.
• 3005:   // but a different (synonymous) one is actually open. Because this is NAV4x
• 3006:   // compatibililty mode, we must close the one that's really open.
• 3010:   // The tag is indeed open, so close it.
• 3021:   // The parent container is open, so close it instead
• 3042:   OpenTransientStyles(theTag);
• 3077:   if (HasOpenContainer(gNoXTags, NS_ARRAY_LENGTH(gNoXTags))) {
• 3086:   // Make sure the head is opened.
• 3087:   if (!(mFlags & NS_DTD_FLAG_HAS_OPEN_HEAD)) {
• 3088:   mFlags |= NS_DTD_FLAG_HAS_OPEN_HEAD;
• 3090:   result = mSink->OpenHead();
• 3112:   // Note: The head context is already opened.
• 3113:   result = mSink->OpenContainer(*aNode);

• 233:   eHTMLTags mExcludingAncestor; //If set, the presence of the excl-ancestor prevents this from opening.
• 254:  static const int kLegalOpen = 0x0004; //Lets BODY, TITLE, SCRIPT to reopen
• 264:  static const int kHandleStrayTag = 0x0400; //If set, we automatically open a start tag
• 265:  static const int kRequiresBody = 0x0800; //If set, then in case of no BODY one will be opened up immediately.

• 55:   * OpennsIHTMLContentSink method: OpenHTML,OpenHead,OpenBody,OpenFrameSet;
• 59:   * IMPORTANT: The parser may Open each container more than
• 64:   * In such cases, the parser will Open the body, pass the text-
• 66:   * re-Opened later when the actual <BODY> tag has been seen.
• 68:   * Containers within the body are Opened and Closed
• 69:   * using the OpenContainer(...) and CloseContainer(...) calls.
• 74:   * NOTE: OpenHTML() and OpenBody() may get called multiple times
• 99:   * This method is used to open the HEAD container. It is useful if a tag
• 100:   * is forcing us to open the head (probably again), like if we find a <meta>
• 103:   NS_IMETHOD OpenHead() = 0;
• 152:   * This method is used to open a generic container in the sink.
• 157:   NS_IMETHOD OpenContainer(const nsIParserNode& aNode) = 0;

• 216:   // Open up the parser for tokenization, building up content

• 51:   * Called to handle the opening tag of an element.

• 61:   // Open the file in a Unix-centric way,
• 64:   FILE* file = fopen(filename, "r");
• 67:   fprintf(stderr, "Can't open file %s", filename);
• 284:   // Open the file in a Unix-centric way,
• 286:   file = fopen(argv[0], "r");
• 289:   fprintf(stderr, "Can't open file %s", argv[0]);

• 72:   PRFileDesc* in = PR_Open(anInputStream, PR_RDONLY, 0777);
• 74:   printf("\nUnable to open input file - %s\n", anInputStream);
• 78:   PRFileDesc* out = PR_Open(anOutputStream,
• 81:   printf("\nUnable to open output file - %s\n", anOutputStream);

• 227:   rv = file->OpenANSIFileDesc("wb", &fp);
• 256:   rv = channel->AsyncOpen(copier, nsnull);

• 97:   localfile->OpenNSPRFileDesc(0660, PR_WRONLY | PR_CREATE_FILE, &outputfile);
• 213:   //Open the master filelist, and read the filenames.

• 415:   if(anInputStream.is_open()){

• 96:   AutoFDClose fd = PR_Open(regfile, PR_CREATE_FILE | PR_WRONLY | PR_TRUNCATE,
• 158:   rv = localSaved->OpenNSPRFileDesc(PR_CREATE_FILE | PR_RDWR, 0664, &fd);
• 184:   rv = localSaved->OpenNSPRFileDesc(PR_CREATE_FILE | PR_WRONLY | PR_TRUNCATE, 0664, &fd);
• 245:   rv = localSaved->OpenNSPRFileDesc(PR_RDONLY, 0, &fd);

• 133:   rv = localSaved->OpenNSPRFileDesc(PR_CREATE_FILE | PR_RDWR, 0664, &fd);
• 163:   if (::RegOpenKeyExW(rootKey, keyName, NULL, KEY_QUERY_VALUE, &existing) ==
• 175:   rv = localSaved->OpenNSPRFileDesc(PR_CREATE_FILE | PR_WRONLY | PR_TRUNCATE, 0664, &fd);
• 232:   nsresult rv = localSaved->OpenNSPRFileDesc(PR_RDONLY, 0, &fd);
• 250:   if (::RegOpenKeyExW(aGlobal ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER,
• 255:   if (::RegOpenKeyExW(rootKey, keyName, 0, KEY_READ, &subKey) == ERROR_SUCCESS) {

• 109:   int file = _open(argv[2], _O_BINARY | _O_RDONLY);
• 111:   fprintf(stderr, "Unable to open icon file.\n");
• 122:   // Open the target library for updating
• 125:   fprintf(stderr, "Unable to open library for modification.\n");

• 648:  nsFileView::IsContainerOpen(PRInt32 aIndex, PRBool* aIsOpen)
• 650:   *aIsOpen = PR_FALSE;
• 788:  nsFileView::ToggleOpenState(PRInt32 aIndex)

• 82:   nsresult OpenChannel();

• 156:   rv = mChannel->AsyncOpen(this, nsnull);

• 97:   nsresult rv = OpenChannel();
• 123:  nsUrlClassifierHashCompleterRequest::OpenChannel()
• 125:   LOG(("nsUrlClassifierHashCompleterRequest::OpenChannel [%p]", this));
• 138:   rv = mChannel->AsyncOpen(this, nsnull);

• 1056:   // Try to open the db, DATABASE_FILENAME.
• 1057:   nsresult OpenDb();
• 1691:   nsresult rv = OpenDb();
• 1807:   nsresult rv = OpenDb();
• 1809:   NS_ERROR("Unable to open database");
• 2929:   nsresult rv = OpenDb();
• 2931:   NS_ERROR("Unable to open database");
• 3077:   nsresult rv = OpenDb();
• 3079:   NS_ERROR("Unable to open database");
• 3207:   // sure that the page cache is freed is to reopen the connection.
• 3210:   OpenDb();
• 3229:   // close/open the connection.
• 3347:   // Start a new transaction. If a transaction is open for an update
• 3369:  nsUrlClassifierDBServiceWorker::OpenDb()
• 3371:   // Connection already open, don't do anything.
• 3375:   LOG(("Opening db\n"));
• 3378:   // open the connection
• 3389:   rv = storageService->OpenDatabase(mDBFile, getter_AddRefs(connection));
• 3391:   // delete the db and try opening again
• 3397:   rv = storageService->OpenDatabase(mDBFile, getter_AddRefs(connection));
• 3417:   rv = storageService->OpenDatabase(mDBFile, getter_AddRefs(connection));

• 141:   * there was no explicit action on the command line (open a default browser

• 72:   * understands, it should perform the appropriate actions (such as opening

• 60:   * Opens the error console window. The console window
• 61:   * is focused if already open.
• 63:   void open();

• 120:   const unsigned long TYPE_OPENSEARCH = 3;

• 53:   * is being used, topmost opener in some cases).

• 103:   nsresult OpenDatabase(PRBool *aDoImport);

• 117:   nsresult rv = OpenDatabase(&doImport);
• 122:   rv = OpenDatabase(&doImport);
• 592:  nsFormHistory::OpenDatabase(PRBool *aDoImport)
• 603:   rv = mStorageService->OpenDatabase(formHistoryFile, getter_AddRefs(mDBConn));
• 917:   // Check that the file exists before we try to open it

• 197:  nsFormFillController::GetPopupOpen(PRBool *aPopupOpen)
• 200:   mFocusedPopup->GetPopupOpen(aPopupOpen);
• 205:  nsFormFillController::SetPopupOpen(PRBool aPopupOpen)
• 208:   if (aPopupOpen) {
• 222:   mFocusedPopup->OpenAutocompletePopup(this, mFocusedInput);
• 817:   PRBool isOpen = PR_FALSE;
• 818:   GetPopupOpen(&isOpen);
• 819:   if (isOpen)

• 74:   nsresult OpenPopup();
• 121:   PRBool mIsOpen;

• 87:   mIsOpen(PR_FALSE),
• 137:   if (mIsOpen)
• 295:   mInput->GetPopupOpen(_retval);
• 326:   mInput->GetPopupOpen(_retval);
• 357:   PRBool isOpen;
• 358:   input->GetPopupOpen(&isOpen);
• 359:   if (isOpen)
• 361:   mPopupClosedByCompositionStart = isOpen;
• 371:   PRBool forceOpenPopup = mPopupClosedByCompositionStart;
• 383:   } else if (forceOpenPopup) {
• 433:   PRBool isOpen;
• 434:   input->GetPopupOpen(&isOpen);
• 435:   if (isOpen) {
• 490:   // Open the popup if there has been a previous search, or else kick off a new search
• 493:   OpenPopup();
• 507:   PRBool isOpen;
• 508:   input->GetPopupOpen(&isOpen);
• 509:   if (isOpen) {
• 515:   // The pop-up is open and has a selection, take its value
• 560:   PRBool isOpen = PR_FALSE;
• 561:   input->GetPopupOpen(&isOpen);
• 562:   if (!isOpen || mRowCount <= 0) {
• 804:  nsAutoCompleteController::IsContainerOpen(PRInt32 index, PRBool *_retval)
• 839:  nsAutoCompleteController::ToggleOpenState(PRInt32 index)
• 957:  nsAutoCompleteController::OpenPopup()
• 963:   mIsOpen = PR_TRUE;
• 964:   return mInput->SetPopupOpen(PR_TRUE);
• 977:   PRBool isOpen;
• 978:   mInput->GetPopupOpen(&isOpen);
• 979:   if (!isOpen)
• 986:   mIsOpen = PR_FALSE;
• 987:   return mInput->SetPopupOpen(PR_FALSE);
• 1286:   // Make sure the popup is open, if necessary, since we now have at least one
• 1290:   OpenPopup();
• 1317:   OpenPopup();

• 252:   // be killed the next time it's opened.

• 57:   * Indicates if the popup is currently open
• 59:   attribute boolean popupOpen;
• 86:   * Option to open the popup only after a certain number of results are available

• 63:   * Indicates if the popup is currently open
• 65:   readonly attribute boolean popupOpen;
• 73:   void openAutocompletePopup(in nsIAutoCompleteInput input, in nsIDOMElement element);

• 198:   * @discussion If this is false, then when GrowlHelperApp is launched to open

• 339:   * and opening it in the GrowlHelperApp. This happens whether or not Growl is

• 155:   rv = wwatch->OpenWindow(0, ALERT_CHROME_URL, "_blank",

• 181:   // If we have no windows open and no explicit calls to
• 258:   /* Enumerate through each open window and close it. It's important to do
• 261:   opens a new window. Ugh. I know. */

• 60:   * defines the lifetime of the application. If there are no windows open

• 160:   // the level of nesting of batches, 0 when no batches are open

• 190:   // Check that the file exists before we try to open it

• 181:   // work. So we will apply it when the node will be reopened and populated.
• 493:   NS_IMETHOD GetContainerOpen(PRBool *aContainerOpen) \
• 494:   { return nsNavHistoryContainerResultNode::GetContainerOpen(aContainerOpen); } \
• 495:   NS_IMETHOD SetContainerOpen(PRBool aContainerOpen) \
• 496:   { return nsNavHistoryContainerResultNode::SetContainerOpen(aContainerOpen); } \
• 559:   virtual nsresult OpenContainer();
• 572:   // when there are children, this stores the open state in the tree
• 725:   virtual nsresult OpenContainer();
• 796:   virtual nsresult OpenContainer();

• 667:   rv = channel->AsyncOpen(listener, nsnull);
• 782:   rv = channel->Open(getter_AddRefs(stream));

• 655:   // Close database connection if open.
• 690:   // open the database
• 693:   rv = mDBService->OpenUnsharedDatabase(mDBFile, getter_AddRefs(mDBConn));
• 713:   rv = mDBService->OpenUnsharedDatabase(mDBFile, getter_AddRefs(mDBConn));
• 717:   // If the database cannot be opened for any reason other than corruption,
• 2962:  // queries, those will be populated when the container is opened.
• 5679:   PRBool open;
• 5680:   nsresult rv = popup->GetPopupOpen(&open);
• 5682:   if (!open)
• 5798:  // the future. This saves you from having to wait if you open a bunch of
• 6261:  // to be used to persist the open state of this container in localstore.rdf
• 6610:  // open in more than one window loading at the same time. This should be rare,

• 96:   * false, so we will open up another channel to get the default favicon, and
• 197:   // We need to return our default icon, so we'll open up a new channel to get
• 209:   rv = newChannel->AsyncOpen(listener, nsnull);

• 431:  // nsNavHistoryContainerResultNode::GetContainerOpen
• 434:  nsNavHistoryContainerResultNode::GetContainerOpen(PRBool *aContainerOpen)
• 436:   *aContainerOpen = mExpanded;
• 441:  // nsNavHistoryContainerResultNode::SetContainerOpen
• 444:  nsNavHistoryContainerResultNode::SetContainerOpen(PRBool aContainerOpen)
• 446:   if (mExpanded && ! aContainerOpen)
• 448:   else if (! mExpanded && aContainerOpen)
• 449:   OpenContainer();
• 454:  // nsNavHistoryContainerResultNode::OpenContainer
• 460:  nsNavHistoryContainerResultNode::OpenContainer()
• 470:   svc->OnContainerNodeOpening(this, GetGeneratingOptions());
• 483:   result->GetView()->ContainerOpened(this);
• 1532:  // updating the tree if necessary. Note that we do not need to be open for
• 1752:  // This function is only valid when the node is opened.
• 2003:  // we do NOT query if we are not open and want to see if we have any children
• 2006:  // When the container is opened, we execute the query and register the
• 2009:  // quickly if the user closes and reopens the container.
• 2141:  // nsNavHistoryQueryResultNode::OpenContainer
• 2143:  // Marks the container as open, rebuilding results if they are invalid. We
• 2144:  // may still have valid results if the container was previously open and
• 2150:  // notification that comes in. This means if you open and close the item
• 2155:  nsNavHistoryQueryResultNode::OpenContainer()
• 2157:   NS_ASSERTION(!mExpanded, "Container must be closed to open it");
• 2169:   result->GetView()->ContainerOpened(
• 2227:   // 1. If it's open, just check mChildren for containers
• 2228:   // 2. Else null the view (keep it in a var), open container, check mChildren
• 2461:  // example, when the container is open). This will clear the list and notify
• 3010:  // opened or whether we need to see if it is empty for twisty drawing. It
• 3018:  // you can more quickly re-open the same folder without doing any work. This
• 3021:  // When a message comes in and the folder is open, we will do the correct
• 3029:  // and we invalidate but the folder itself is visible (its parent is open),
• 3073:  // nsNavHistoryFolderResultNode::OpenContainer
• 3075:  // See nsNavHistoryQueryResultNode::OpenContainer
• 3078:  nsNavHistoryFolderResultNode::OpenContainer()
• 3090:   svc->OnContainerNodeOpening(
• 3103:   result->GetView()->ContainerOpened(
• 3151:  // open, and doing another statement might make it unhappy in some cases.
• 3918:   // We stop observing when root node is closed, but when reopening it result
• 4355:   // opened, meaning we cannot optimize this code path for changes done to

• 337:   // the level of nesting of batches, 0 when no batches are open
• 465:   * Indicates if we should close an open database connection or not.
• 466:   * Note: A valid database connection must be opened if this is true.

• 2081:   // on success, leave the statement open, the caller will set the value

• 50:   * being opened. It can use the property bag on every result node to store data
• 65:   * The container node for the container being opened. Note that all
• 73:   void onContainerNodeOpening(in nsINavHistoryContainerResultNode aContainer,
• 80:   * call. This only happens when the container itself goes from the open state

• 258:   * been precomputed. For queries and bookmark folders, being open means they
• 262:   attribute boolean containerOpen;
• 266:   * when the container is open or closed. When the container is closed, it
• 269:   * it will return true. When the container is open, it will always be
• 280:   * @throws NS_ERROR_NOT_AVAILABLE if containerOpen is false.
• 306:   * container API. TO BE CALLED FROM nsIDynamicContainer::OnContainerOpening()
• 317:   * container API. TO BE CALLED FROM nsIDynamicContainer::OnContainerOpening()
• 330:   * container API. TO BE CALLED FROM nsIDynamicContainer::OnContainerOpening()
• 345:   * container API. TO BE CALLED FROM nsIDynamicContainer::OnContainerOpening()
• 362:   * container API. TO BE CALLED FROM nsIDynamicContainer::OnContainerOpening()
• 375:   * dynamic container API. TO BE CALLED FROM nsIDynamicContainer::OnContainerOpening()
• 385:   * TO BE CALLED FROM nsIDynamicContainer::OnContainerOpening and
• 489:   * Called after a container node went from closed to opened.
• 491:   void containerOpened(in nsINavHistoryContainerResultNode item);
• 494:   * Called after a container node went from opened to closed. This will be
• 615:   * This is the root of the results. Remember that you need to open all
• 1136:   * failed due to the inability to open the places.sqlite
• 1224:   * is being opened as a result of following a bookmark. If this URI is loaded

• 89:  #define PREF_BDM_ALERTONEXEOPEN "browser.download.manager.alertOnEXEOpen"
• 278:   nsresult rv = storage->OpenDatabase(dbFile, getter_AddRefs(conn));
• 284:   rv = storage->OpenDatabase(dbFile, getter_AddRefs(conn));
• 299:   nsresult rv = storage->OpenSpecialDatabase("memory", getter_AddRefs(conn));
• 2183:   // because if it is, they'll click open the download manager and
• 2225:   // open executable content. If the option is set, add meta data to the
• 2233:   (void)pref->GetBoolPref(PREF_BDM_ALERTONEXEOPEN, &alert);
• 2240:   NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
• 2717:   // open with the appropriate application
• 2718:   retVal = OpenWithApplication();
• 2756:  nsDownload::OpenWithApplication()

• 390:   * Opens the downloaded file with the appropriate application, which is
• 396:   * This function was adopted from nsExternalAppHandler::OpenWithApplication
• 399:   nsresult OpenWithApplication();

• 60:   * The id of the download to be preselected upon opening.

• 819:   rv = mListFile->OpenANSIFileDesc("w", &writeFile);

• 39:  #include <openssl/md5.h>
• 40:  #include <openssl/sha.h>

• 61:   // Returns false if opening the file failed or if the |cpu_type| is not
• 69:   // Read |size| bytes from the opened file at |offset| into |buffer|
• 87:   // File descriptor to the opened file

• 56:   // Returns false if opening the file failed or if the |cpu_type| is not

• 79:   // Opens the given file. For executable files, the corresponding pdb
• 80:   // file must be available; Open will be if it is not.
• 81:   // If there is already a pdb file open, it is automatically closed.
• 83:   bool Open(const wstring &file, FileFormat format);
• 86:   // and opens it. If there is already a pdb file open, it is automatically
• 88:   bool OpenExecutable(const wstring &exe_file);
• 101:   // Sets uses_guid to true if the opened file uses a new-style CodeView
• 102:   // record with a 128-bit GUID, or false if the opened file uses an old-style
• 150:   // The session for the currently-open pdb file.

• 859:   // Opens the minidump file, or if already open, seeks to the beginning.
• 860:   bool Open();
• 885:   // Set based on the |path_| member by Open, which is called by Read.

• 105:   // Opens the checkpoint file with the specified mode.
• 107:   int OpenCheckpointFile(const wchar_t *mode, FILE **fd);

• 31:  // intended to be used with the Google Breakpad open source crash handling
• 46:  // The user of this class can Open() a file and add minidump streams, data, and
• 52:  // writer.Open("/tmp/minidump.dmp");
• 67:   // Open |path| as the destination of the minidump data. Any existing file
• 70:   bool Open(const char *path);

• 212:   int fd = open(lastCrashTimeFilename,
• 278:   int fd = open(extraDataPath,
• 470:   nsresult rv = localFile->OpenNSPRFileDesc(PR_WRONLY | PR_CREATE_FILE, 00600,
• 489:   nsresult rv = localFile->OpenNSPRFileDesc(PR_RDONLY, 0, &fd);

• 136:  std::ifstream* UIOpenRead(const std::string& filename);
• 137:  std::ofstream* UIOpenWrite(const std::string& filename, bool append=false);

• 169:   if (RegOpenKey(HKEY_LOCAL_MACHINE, key, &hRegKey) == ERROR_SUCCESS) {
• 177:   if (RegOpenKey(HKEY_CURRENT_USER, key, &hRegKey) == ERROR_SUCCESS) {
• 221:   if (RegOpenKey(HKEY_LOCAL_MACHINE, key, &hRegKey) == ERROR_SUCCESS) {
• 228:   if (RegOpenKey(HKEY_CURRENT_USER, key, &hRegKey) == ERROR_SUCCESS) {
• 287:  typedef HANDLE (WINAPI*OpenThemeDataPtr)(HWND hwnd, LPCWSTR pszClassList);
• 304:   OpenThemeDataPtr openTheme =
• 305:   (OpenThemeDataPtr)GetProcAddress(themeDLL, "OpenThemeData");
• 311:   if (!openTheme || !closeTheme || !getThemePartSize) {
• 316:   HANDLE buttonTheme = openTheme(hwnd, L"Button");
• 700:   OpenClipboard(hwnd)) {
• 1070:   // Open the AVI resource for the throbber
• 1071:   Animate_Open(GetDlgItem(hwndDlg, IDC_THROBBER),
• 1386:  ifstream* UIOpenRead(const string& filename)
• 1390:   // The "open" method on pre-MSVC8 ifstream implementations doesn't accept a
• 1391:   // wchar_t* filename, so use _wfopen directly in that case. For VC8 and
• 1392:   // later, _wfopen has been deprecated in favor of _wfopen_s, which does
• 1393:   // not exist in earlier versions, so let the ifstream open the file itself.
• 1396:   file->open(UTF8ToWide(filename).c_str(), ios::in);
• 1398:   ifstream* file = new ifstream(_wfopen(UTF8ToWide(filename).c_str(), L"r"));
• 1404:  ofstream* UIOpenWrite(const string& filename, bool append) // append=false
• 1408:   // The "open" method on pre-MSVC8 ifstream implementations doesn't accept a
• 1409:   // wchar_t* filename, so use _wfopen directly in that case. For VC8 and
• 1410:   // later, _wfopen has been deprecated in favor of _wfopen_s, which does
• 1411:   // not exist in earlier versions, so let the ifstream open the file itself.
• 1414:   file->open(UTF8ToWide(filename).c_str(), append ? ios::out | ios::app
• 1417:   ofstream* file = new ofstream(_wfopen(UTF8ToWide(filename).c_str(),

• 95:  // handle from dlopen'ing libgnome
• 97:  // handle from dlopen'ing libgnomeui
• 560:   gnomeLib = dlopen("libgnome-2.so.0", RTLD_LAZY);
• 564:   gnomeuiLib = dlopen("libgnomeui-2.so.0", RTLD_LAZY);
• 890:  std::ifstream* UIOpenRead(const string& filename)
• 895:  std::ofstream* UIOpenWrite(const string& filename, bool append) // append=false

• 160:   ifstream* f = UIOpenRead(path);
• 162:   if (f->is_open()) {
• 197:   ofstream* f = UIOpenWrite(path.c_str());
• 199:   if (f->is_open()) {
• 220:  static void OpenLogFile()
• 223:   gLogStream.reset(UIOpenWrite(logPath.c_str(), true));
• 303:   ofstream* reportFile = UIOpenWrite(reportPath);
• 304:   if (reportFile->is_open()) {
• 330:   ofstream* file = UIOpenWrite(path);
• 331:   if (!file->is_open()) {
• 534:   OpenLogFile();

• 255:   rv = statusFile->OpenANSIFileDesc("r", &fp);
• 273:   nsresult rv = statusFile->OpenANSIFileDesc("w", &fp);
• 296:   rv = versionFile->OpenANSIFileDesc("r", &fp);

• 265:   fprintf(stderr, "Cannot exceed hard limit for open files");

• 68:   nsresult HandleOpenOneDoc(const CFURLRef file, OSType inFileType);
• 75:   nsresult OpenURL(const char* aURL);
• 77:   nsresult OpenWindow(const char *chrome, const PRUnichar *url);

• 229:  nsresult nsMacCommandLine::HandleOpenOneDoc(const CFURLRef file, OSType inFileType)
• 239:   // Can we open the file?
• 241:   rv = inFile->OpenANSIFileDesc("r", &fp);
• 263:   // rather than trying to open the file as a URL
• 270:   // the app is opened with documents on the mac, they'll be handled the same
• 304:   // the app is opened with documents on the mac, they'll be handled the same

• 196:   * supports only the "WWW_OpenURL" topic. This should be reasonably
• 240:   * point where those requests can be serviced (e.g., open a browser
• 275:   * 2. If it is registered the OS sends a DDE request with the WWW_OpenURL topic
• 277:   * key for the verb (e.g. open).
• 279:   * verb's (e.g. open) command registry key.
• 281:   * the WWW_OpenURL topic and the params as specified in the default value of
• 282:   * the ddeexec registry key for the verb (e.g. open).
• 284:   * WWW_OpenURL topic and the params as specified in the ifexec registry key
• 285:   * for the verb (e.g. open).
• 289:   * WWW_OpenURL topic and the params as specified in the default value of the
• 290:   * ddeexec registry key (e.g. "%1",,0,0,,,, where '%1' is the url to open)
• 291:   * for the verb (e.g. open).
• 296:   * application will wait for the DDE message to open the url.
• 344:   static nsresult OpenWindow( const char *urlstr, const char *args );
• 345:   static nsresult OpenBrowserWindow();
• 352:   topicOpenURL,
• 393:   int hCrt = ::_open_osfhandle( (long)GetStdHandle( STD_OUTPUT_HANDLE ),
• 396:   FILE *hf = ::_fdopen( hCrt, "w" );
• 406:   hCrt = ::_open_osfhandle( (long)::GetStdHandle( STD_ERROR_HANDLE ),
• 409:   FILE *hf = ::_fdopen( hCrt, "w" );
• 420:   hCrt = ::_open_osfhandle( (long)::GetStdHandle( STD_INPUT_HANDLE ),
• 423:   FILE *hf = ::_fdopen( hCrt, "r" );
• 475:  const char * const topicNames[] = { "WWW_OpenURL",
• 980:   case topicOpenURL: {
• 981:   // Open a given URL...
• 991:   // "" means to open the URL in a new window.
• 1025:   // There is not a window open
• 1152:   // Default is to open in current window.
• 1163:   // "" means to open the URL in a new window.
• 1290:   OpenBrowserWindow();
• 1457:  nsNativeAppSupportWin::OpenWindow( const char*urlstr, const char *args ) {
• 1468:   rv = wwatch->OpenWindow(0, urlstr, "_blank", "chrome,dialog=no,all",
• 1543:  nsNativeAppSupportWin::OpenBrowserWindow()
• 1547:   // Open the argument URL in the most recently used Navigator window.
• 1548:   // If there is no Nav window, open a new one.
• 1557:   // out to the OpenWindow call when things go awry.
• 1561:   // Have to open a new one.
• 1583:   rv = bwin->OpenURI( uri, 0,
• 1584:   nsIBrowserDOMWindow::OPEN_DEFAULTWINDOW,
• 1585:   nsIBrowserDOMWindow::OPEN_EXTERNAL,
• 1595:   // open a new window if caller requested it or if anything above failed

• 82:   * (as if there were still additional top-level windows open).
• 108:   * opening a new window, followed by immediately
• 138:   void ReOpen();

• 227:   * supports only the "WWW_OpenURL" topic. This should be reasonably
• 271:   * point where those requests can be serviced (e.g., open a browser
• 334:   static nsresult OpenWindow( const char *urlstr, const char *args );
• 335:   static nsresult OpenBrowserWindow();
• 339:   topicOpenURL,
• 394:  const char * const topicNames[] = { "WWW_OpenURL",
• 1130:   case topicOpenURL: {
• 1131:   // Open a given URL...
• 1141:   // to open the URL in a new window, the old OS/2 code
• 1174:   // There is not a window open
• 1306:   // to open the URL in a new window, the old OS/2 code
• 1419:   OpenBrowserWindow();
• 1610:  nsNativeAppSupportOS2::OpenWindow( const char*urlstr, const char *args ) {
• 1621:   rv = wwatch->OpenWindow(0, urlstr, "_blank", "chrome,dialog=no,all",
• 1703:  nsNativeAppSupportOS2::OpenBrowserWindow()
• 1707:   // Open the argument URL in the most recently used Navigator window.
• 1708:   // If there is no Nav window, open a new one.
• 1717:   // out to the OpenWindow call when things go awry.
• 1721:   // Have to open a new one.
• 1743:   rv = bwin->OpenURI( uri, 0,
• 1744:   nsIBrowserDOMWindow::OPEN_DEFAULTWINDOW,
• 1745:   nsIBrowserDOMWindow::OPEN_EXTERNAL,
• 1755:   // open a new window if caller requested it or if anything above failed

• 55:   virtual void Open();
• 101:  nsSplashScreenWin::Open()
• 103:   if (mIsOpen || mDialog)
• 106:   mIsOpen = PR_TRUE;
• 213:   mIsOpen = PR_FALSE;

• 59:   virtual void Open() = 0;
• 65:   PRBool IsOpen() { return mIsOpen; }
• 68:   nsSplashScreen() : mIsOpen(PR_FALSE) { }
• 69:   PRBool mIsOpen;

• 65:  // Two static helpers for future - if we decide to use OpenBrowserWindow, like we do in SeaMonkey
• 261:   // Here we get stuck when starting from file-click or "OpenWith".
• 309:  // TODO: try to use OpenURI here if there is navWin, maybe using special function
• 310:  // OpenBrowserWindow which calls OpenURI like we do for SeaMonkey,
• 362:  nsNativeAppSupportBeOS::ReOpen()

• 554:   * restart and the app has been launched by the Windows shell to open an url.
• 768:   if (!OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &hToken) ||
• 1253:   "\t-no-remote\t\tOpen new instance, not a new window in running instance.\n"
• 1841:   rv = windowWatcher->OpenWindow(nsnull,
• 2268:   lf->OpenNSPRFileDesc(PR_WRONLY | PR_CREATE_FILE | PR_TRUNCATE, 0600, &fd);
• 2575:   splashScreen->Open();
• 2598:   realMode |= SEM_NOGPFAULTERRORBOX | SEM_NOOPENFILEERRORBOX;
• 2977:   // Open the display ourselves instead of using gtk_init, so that we can
• 2979:   // opens.
• 3023:   display = gdk_display_open(display_name);
• 3025:   PR_fprintf(PR_STDERR, "Error: cannot open display: %s\n", display_name);

• 78:   rv = lfile->OpenNSPRFileDesc(PR_WRONLY | PR_APPEND | PR_CREATE_FILE,

• 80:  nsNativeAppSupportBase::ReOpen()

• 53:  ArchiveReader::Open(const WCHAR *path)
• 55:  ArchiveReader::Open(const char *path)
• 62:   mArchive = mar_wopen(path);
• 64:   mArchive = mar_open(path);
• 89:   int fd = _open(dest, _O_BINARY|_O_CREAT|_O_TRUNC|_O_WRONLY, item->flags);
• 96:   FILE *fp = fdopen(fd, "wb");

• 47:  # define NS_tfopen _wfopen
• 48:  # define OPEN_MODE L"rb"
• 50:  # define NS_tfopen fopen
• 51:  # define OPEN_MODE "r"
• 118:   AutoFILE fp = NS_tfopen(path, OPEN_MODE);

• 69:  # define NS_topen _wopen
• 70:  # define NS_tfopen _wfopen
• 81:  # define NS_topen open
• 82:  # define NS_tfopen fopen
• 313:   gLogFP = NS_tfopen(logFile, NS_T("w"));
• 406:  static int ensure_open(const char *path, int flags, int options)
• 409:   return open(path, flags, options);
• 444:   AutoFD sfd = open(spath, O_RDONLY | _O_BINARY);
• 446:   LOG(("copy_file: failed to open or stat: %d,%s,%d\n", (int) sfd, spath, errno));
• 450:   AutoFD dfd = ensure_open(dpath, O_WRONLY | O_TRUNC | O_CREAT | _O_BINARY, ss.st_mode);
• 452:   LOG(("copy_file: failed to open: %s,%d\n", dpath, errno));
• 855:   FILE *fp = NS_tfopen(spath, NS_T("wb"));
• 865:   // no need to open all of the patch files and read all of
• 868:   pfd = NS_topen(spath, O_RDONLY | _O_BINARY);
• 876:   AutoFD ofd = open(mFile, O_RDONLY | _O_BINARY);
• 905:   AutoFD ofd = ensure_open(mFile, O_WRONLY | O_TRUNC | O_CREAT | _O_BINARY, ss.st_mode);
• 1175:   AutoFD fd = NS_topen(filename, O_WRONLY | O_TRUNC | O_CREAT | _O_BINARY, 0644);
• 1194:   // open ZIP archive and process...
• 1199:   int rv = gArchiveReader.Open(dataFile);
• 1235:   HANDLE parent = OpenProcess(SYNCHRONIZE, FALSE, (DWORD) pid);
• 1278:   OPEN_ALWAYS,
• 1297:   OPEN_ALWAYS,
• 1488:   FILE *fp = NS_tfopen(manifest, NS_T("wb"));
• 1497:   AutoFD mfd = NS_topen(manifest, O_RDONLY | _O_BINARY);

• 53:   int Open(const WCHAR *path);
• 55:   int Open(const char *path);

• 68:   * @param fd Must have been opened for reading, and be at the beginning
• 80:   * @param filefd Must have been opened for writing. Should be truncated

• 78:   rv = mKey->Open(nsIWindowsRegKey::ROOT_KEY_CURRENT_USER, key,

• 91:  nsGnomeVFSMimeApp::GetCanOpenMultipleFiles(PRBool* aCanOpen)
• 93:   *aCanOpen = mApp->can_open_multiple_files;
• 316:   if (aKey == APP_KEY_CAN_OPEN_MULTIPLE)
• 317:   key = GNOME_VFS_APPLICATION_REGISTRY_CAN_OPEN_MULTIPLE_FILES;

• 47:   * object creates an instance of session history for each open window.

• 92:   void open(in nsISupports aState, in nsISHEntry aSHEntry);

• 92:  nsDSURIContentListener::OnStartURIOpen(nsIURI* aURI, PRBool* aAbortOpen)
• 98:   *aAbortOpen = PR_TRUE;
• 105:   return parentListener->OnStartURIOpen(aURI, aAbortOpen);
• 125:   nsCOMPtr<nsIChannel> aOpenedChannel = do_QueryInterface(request);
• 127:   if (aOpenedChannel)
• 128:   aOpenedChannel->GetLoadFlags(&loadFlags);

• 597:   // opening the channel, then it is not necessary to hold a reference to the
• 609:   chan->AsyncOpen(listener, nsnull);
• 611:   // Even if AsyncOpen failed, we still count this as a successful ping. It's
• 612:   // possible that AsyncOpen may have failed after triggering some background
• 2482:   PRBool aConsiderOpener)
• 2497:   // Bug 103638: Targets with same name in different windows open in wrong
• 2508:   // its opener per rule (1) or (2).
• 2545:   if (!aConsiderOpener) {
• 2557:   nsCOMPtr<nsIDOMWindowInternal> targetOpener;
• 2558:   targetInternal->GetOpener(getter_AddRefs(targetOpener));
• 2559:   nsCOMPtr<nsIWebNavigation> openerWebNav(do_GetInterface(targetOpener));
• 2560:   nsCOMPtr<nsIDocShellTreeItem> openerItem(do_QueryInterface(openerWebNav));
• 2562:   if (!openerItem) {
• 2566:   return CanAccessItem(openerItem, aAccessingItem, PR_FALSE);
• 3469:   popupState = openAllowed;
• 3472:   popupState = openOverridden;
• 5290:   nsIProtocolHandler::URI_OPENING_EXECUTES_SCRIPT, &isjs);
• 6063:   principal = piDOMWindow->GetOpenerScriptPrincipal();
• 6744:   rv = mContentViewer->Open(windowState, mLSHE);
• 7003:   nsCOMPtr<nsIChannel> aOpenedChannel = do_QueryInterface(request);
• 7004:   if (aOpenedChannel) {
• 7005:   aOpenedChannel->GetURI(getter_AddRefs(mLoadingURI));
• 7019:   PRBool onLocationChangeNeeded = OnLoadingSite(aOpenedChannel, PR_FALSE);
• 7023:   NS_ENSURE_SUCCESS(aOpenedChannel->
• 7041:   aOpenedChannel->SetLoadGroup(mLoadGroup);
• 7044:   aOpenedChannel->GetLoadFlags(&loadFlags);
• 7047:   aOpenedChannel->SetLoadFlags(loadFlags);
• 7056:   aOpenedChannel->SetNotificationCallbacks(this);
• 7105:   nsCOMPtr<nsIChannel> aOpenedChannel = do_QueryInterface(request);
• 7127:   aOpenedChannel,
• 7336:   // still possible for an evil site to open a window and access
• 7630:   rv = win->Open(EmptyString(), // URL to load
• 7635:   // In some cases the Open call doesn't actually result in a new
• 7636:   // window being opened. We can detect these cases by examining the
• 8132:   // open a channel for the url
• 8148:   nsresult rv2 = mContentListener->OnStartURIOpen(aURI, &abort);
• 8304:   // If this is a file: load opened from another file: then it may need
• 8493:   rv = aURILoader->OpenURI(aChannel,
• 9167:   // We're loading a URL that will execute script from inside asyncOpen.
• 9855:   !(chromeFlags & nsIWebBrowserChrome::CHROME_OPENAS_CHROME);
• 9857:   // If our window is modal and we're not opened as chrome, make
• 9881:   PRBool openDocHasDetachedEditor = mOSHE && mOSHE->HasDetachedEditor();
• 9882:   if (!mEditorData && !mIsBeingDestroyed && !openDocHasDetachedEditor) {
• 10476:   // chance to AsyncOpen() before we suspend it.

• 336:   // Actually open a channel and perform a URI load. Note: whatever owner is
• 523:   PRBool aConsiderOpener = PR_TRUE);
• 555:   // When restoring a content viewer from session history, open() is called
• 579:   // This simulates a channel open, and defers the real work until

• 62:   * This method must be called immediately after AsyncOpen() has been called
• 82:   * The new channel. This channel is not opened yet.

• 481:   * editor data in the open document's session history entry. This

• 74:  ** This is the primary structure to represent any active open socket,
• 103:   PR_TRANSMITFILE_KEEP_OPEN = 0, /* socket is left open after file
• 394:   PRFileInfoFN fileInfo; /* Get information about an open file */
• 570:   * FUNCTION: PR_Open
• 571:   * DESCRIPTION: Open a file for reading, writing, or both.
• 574:   * The path name of the file to be opened
• 579:   * PR_RDONLY Open for reading only.
• 580:   * PR_WRONLY Open for writing only.
• 581:   * PR_RDWR Open for reading and writing.
• 598:   * If the file is successfully opened,
• 600:   * created for the newly opened file.
• 601:   * Returns a NULL pointer if the open
• 612:  /* Open flags */
• 626:  ** The 'mode' argument may be ignored by PR_Open on other platforms.
• 640:  NSPR_API(PRFileDesc*) PR_Open(const char *name, PRIntn flags, PRIntn mode);
• 644:   * FUNCTION: PR_OpenFile
• 646:   * Open a file for reading, writing, or both.
• 647:   * PR_OpenFile has the same prototype as PR_Open but implements
• 666:  NSPR_API(PRFileDesc*) PR_OpenFile(
• 673:  NSPR_API(PRFileDesc*) PR_OpenFileUTF16(
• 799:   * file is open.
• 866:   * FUNCTION: PR_GetOpenFileInfo, PR_GetOpenFileInfo64
• 868:   * Get information about an open file referred to by the
• 872:   * A reference to a valid, open file.
• 881:  NSPR_API(PRStatus) PR_GetOpenFileInfo(PRFileDesc *fd, PRFileInfo *info);
• 882:  NSPR_API(PRStatus) PR_GetOpenFileInfo64(PRFileDesc *fd, PRFileInfo64 *info);
• 1031:   * FUNCTION: PR_OpenDir
• 1033:   * Open the directory by the given name
• 1036:   * path name of the directory to be opened
• 1040:   * If the directory is sucessfully opened, a PRDir object is
• 1042:   * If the directory cannot be opened, a NULL pointer is returned.
• 1049:  NSPR_API(PRDir*) PR_OpenDir(const char *name);
• 1055:  NSPR_API(PRDirUTF16*) PR_OpenDirUTF16(const PRUnichar *name);
• 1064:   * pointer to a PRDir object that designates an open directory
• 1134:   * See 'mode' definiton in PR_Open().
• 1189:   * to the PRFileDesc created for the newly opened UDP socket.
• 1208:   * to the PRFileDesc created for the newly opened TCP socket.
• 1218:   * FUNCTION: PR_OpenUDPSocket
• 1227:   * Upon successful completion, PR_OpenUDPSocket returns a pointer
• 1228:   * to the PRFileDesc created for the newly opened UDP socket.
• 1234:  NSPR_API(PRFileDesc*) PR_OpenUDPSocket(PRIntn af);
• 1238:   * FUNCTION: PR_OpenTCPSocket
• 1248:   * to the PRFileDesc created for the newly opened TCP socket.
• 1254:  NSPR_API(PRFileDesc*) PR_OpenTCPSocket(PRIntn af);

• 83:  /* The directory could not be opened */
• 84:  #define PR_DIRECTORY_OPEN_ERROR (-5988L)
• 134:  /* Process open FD table is full */
• 137:  /* System open FD table is full */

• 38:  #ifndef nspr_openbsd_defs_h___
• 39:  #define nspr_openbsd_defs_h___
• 43:  #define PR_LINKER_ARCH "openbsd"
• 44:  #define _PR_SI_SYSNAME "OPENBSD"
• 238:  #if OpenBSD1_3 == 1L
• 242:  #endif /* nspr_openbsd_defs_h___ */

• 321:  #define _MD_OPEN_DIR _MD_open_dir
• 328:  #define _MD_OPEN _MD_open
• 329:  #define _MD_OPEN_FILE _MD_open
• 340:  #define _MD_GETOPENFILEINFO _MD_getopenfileinfo
• 341:  #define _MD_GETOPENFILEINFO64 _MD_getopenfileinfo64
• 521:  NSPR_API(PRStatus) _MD_open_dir(struct _MDDir *md,const char *name);
• 527:  NSPR_API(PRInt32) _MD_open(const char *name, PRIntn osflags, PRIntn mode);
• 538:  NSPR_API(PRInt32) _MD_getopenfileinfo(const PRFileDesc *fd, PRFileInfo *info);
• 539:  NSPR_API(PRInt32) _MD_getopenfileinfo64(const PRFileDesc *fd, PRFileInfo64 *info);

• 299:  #define _MD_OPEN _PR_MD_OPEN
• 300:  #define _MD_OPEN_FILE _PR_MD_OPEN_FILE
• 309:  #define _MD_GETOPENFILEINFO _PR_MD_GETOPENFILEINFO
• 310:  #define _MD_GETOPENFILEINFO64 _PR_MD_GETOPENFILEINFO64
• 389:  #define _MD_OPEN_DIR _PR_MD_OPEN_DIR
• 617:  #define _MD_OPEN_SEMAPHORE _PR_MD_OPEN_SEMAPHORE

• 144:   || defined(NETBSD) || defined(OPENBSD) || defined(BSDI) \
• 201:   || defined(FREEBSD) || defined(NETBSD) || defined(OPENBSD) \
• 254:  #elif defined(OPENBSD)
• 292:   || defined(FREEBSD) || defined(NETBSD) || defined(OPENBSD) \

• 209:  #define _PR_OPEN_POLL_SEM(_sem) usopenpollsema(_sem, 0666)

• 118:  extern FILE *popen(const char *, const char *);

• 49:  extern void _MD_win32_map_opendir_error(PRInt32 err);
• 50:  #define _PR_MD_MAP_OPENDIR_ERROR _MD_win32_map_opendir_error
• 142:  extern void _MD_win32_map_open_error(PRInt32 err);
• 143:  #define _PR_MD_MAP_OPEN_ERROR _MD_win32_map_open_error

• 197:  #define _MD_OPEN (_PR_MD_OPEN)
• 198:  #define _MD_OPEN_FILE (_PR_MD_OPEN)
• 208:  #define _MD_GETOPENFILEINFO (_PR_MD_GETOPENFILEINFO)
• 209:  #define _MD_GETOPENFILEINFO64 (_PR_MD_GETOPENFILEINFO64)
• 302:  #define _MD_OPEN_DIR (_PR_MD_OPEN_DIR)

• 256:  #define _MD_OPEN _PR_MD_OPEN
• 257:  #define _MD_OPEN_FILE _PR_MD_OPEN_FILE
• 267:  #define _MD_GETOPENFILEINFO _PR_MD_GETOPENFILEINFO
• 268:  #define _MD_GETOPENFILEINFO64 _PR_MD_GETOPENFILEINFO64
• 283:  #define _MD_OPEN_FILE_UTF16 _PR_MD_OPEN_FILE_UTF16
• 284:  #define _MD_OPEN_DIR_UTF16 _PR_MD_OPEN_DIR_UTF16
• 377:  #define _MD_OPEN_DIR _PR_MD_OPEN_DIR
• 558:  #define _MD_OPEN_SEMAPHORE _PR_MD_OPEN_SEMAPHORE

• 49:  extern void _MD_unix_map_opendir_error(int err);
• 50:  #define _PR_MD_MAP_OPENDIR_ERROR _MD_unix_map_opendir_error
• 145:  extern void _MD_unix_map_open_error(int err);
• 146:  #define _PR_MD_MAP_OPEN_ERROR _MD_unix_map_open_error

• 49:  NSPR_API(void) _MD_os2_map_opendir_error(PRInt32 err);
• 50:  #define _PR_MD_MAP_OPENDIR_ERROR _MD_os2_map_opendir_error
• 148:  NSPR_API(void) _MD_os2_map_open_error(PRInt32 err);
• 149:  #define _PR_MD_MAP_OPEN_ERROR _MD_os2_map_open_error

• 75:  #elif defined(OPENBSD)
• 76:  #include "md/_openbsd.h"

• 348:  extern PRStatus _MD_open_dir(struct _MDDir *, const char *);
• 351:  extern PRInt32 _MD_open(const char *name, PRIntn osflags, PRIntn mode);
• 355:  extern PRInt32 _MD_getopenfileinfo(const PRFileDesc *fd, PRFileInfo *info);
• 356:  extern PRInt32 _MD_getopenfileinfo64(const PRFileDesc *fd, PRFileInfo64 *info);
• 370:  #define _MD_OPEN_DIR(dir, name) _MD_open_dir(dir, name)
• 373:  #define _MD_OPEN(name, osflags, mode) _MD_open(name, osflags, mode)
• 374:  #define _MD_OPEN_FILE(name, osflags, mode) _MD_open(name, osflags, mode)
• 382:  #define _MD_GETOPENFILEINFO(fd, info) _MD_getopenfileinfo(fd, info)
• 383:  #define _MD_GETOPENFILEINFO64(fd, info) _MD_getopenfileinfo64(fd, info)
• 618:  typedef PRIntn (*_MD_Open64)(const char *path, int oflag, ...);
• 626:   _MD_Open64 _open64;

• 58:  ** given in the PR_OpenSharedMemory() call, a protocol for using the
• 62:  ** PR_OpenSharedMemory() will create the shared memory segment, if it
• 63:  ** does not already exist, or open a connection that the existing
• 67:  ** PR_OpenSharedMemory() to map the memory segment to an address in
• 88:  ** The name passed to PR_OpenSharedMemory() should be a valid filename
• 89:  ** for a unix platform. PR_OpenSharedMemory() creates file using the
• 103:  ** All names provided to PR_OpenSharedMemory() should be valid
• 145:  ** FUNCTION: PR_OpenSharedMemory()
• 148:  ** PR_OpenSharedMemory() creates a new shared-memory segment or
• 169:  ** mode -- Same as is passed to PR_Open()
• 180:   PR_OpenSharedMemory(
• 186:  /* Define values for PR_OpenShareMemory(...,create) */
• 198:  ** shm -- The handle returned from PR_OpenSharedMemory().
• 229:  ** shm -- The handle returned from PR_OpenSharedMemory().
• 253:  ** shm -- The handle returned from PR_OpenSharedMemory().

• 71:   * PR_OpenSemaphore --
• 73:   * Create or open a named semaphore with the specified name.
• 83:   * interpretation as the mode argument to PR_Open) and the
• 92:  NSPR_API(PRSem *) PR_OpenSemaphore(

• 55:  ** that do not inherit the shared memory from opening the file and
• 81:  ** fm = PR_OpenAnonFileMap(dirName, size, FilemapProt);
• 104:  ** fm = PR_OpenAnonFileMap(dirName, size, FilemapProt);
• 141:  ** PR_OpenAnonFileMap() -- Creates an anonymous file-mapped shared memory
• 144:  ** PR_OpenAnonFileMap() creates an anonymous shared memory. If the
• 148:  ** On Unix platforms, PR_OpenAnonFileMap() uses 'dirName' as a
• 167:  PR_OpenAnonFileMap(
• 229:  ** previously created with PR_OpenAnonFileMap().

• 1049:  extern PRStatus _PR_MD_OPEN_DIR(_MDDir *md,const char *name);
• 1050:  #define _PR_MD_OPEN_DIR _MD_OPEN_DIR
• 1059:  extern PRSem * _PR_MD_OPEN_SEMAPHORE(
• 1061:  #define _PR_MD_OPEN_SEMAPHORE _MD_OPEN_SEMAPHORE
• 1083:  extern PROsfd _PR_MD_OPEN(const char *name, PRIntn osflags, PRIntn mode);
• 1084:  #define _PR_MD_OPEN _MD_OPEN
• 1086:  extern PROsfd _PR_MD_OPEN_FILE(const char *name, PRIntn osflags, PRIntn mode);
• 1087:  #define _PR_MD_OPEN_FILE _MD_OPEN_FILE
• 1129:  extern PRStatus _PR_MD_OPEN_DIR_UTF16(_MDDirUTF16 *md, const PRUnichar *name);
• 1130:  #define _PR_MD_OPEN_DIR_UTF16 _MD_OPEN_DIR_UTF16
• 1132:  extern PROsfd _PR_MD_OPEN_FILE_UTF16(const PRUnichar *name, PRIntn osflags, PRIntn mode);
• 1133:  #define _PR_MD_OPEN_FILE_UTF16 _MD_OPEN_FILE_UTF16
• 1314:  extern PRInt32 _PR_MD_GETOPENFILEINFO(const PRFileDesc *fd, PRFileInfo *info);
• 1315:  #define _PR_MD_GETOPENFILEINFO _MD_GETOPENFILEINFO
• 1317:  extern PRInt32 _PR_MD_GETOPENFILEINFO64(const PRFileDesc *fd, PRFileInfo64 *info);
• 1318:  #define _PR_MD_GETOPENFILEINFO64 _MD_GETOPENFILEINFO64
• 1695:  ** - _PR_FILEDESC_OPEN: The OS fd is open.
• 1697:  ** is still open but is unusable. The only operation allowed
• 1703:  #define _PR_FILEDESC_OPEN 0xaaaaaaaa /* 1010101... */
• 1733:   * file on write if the file was opened in
• 2006:   PRSize size; /* from open */
• 2007:   PRIntn mode; /* from open */
• 2008:   PRIntn flags; /* from open */
• 2022:  extern PRSharedMemory * _MD_OpenSharedMemory(
• 2028:  #define _PR_MD_OPEN_SHARED_MEMORY _MD_OpenSharedMemory
• 2042:  extern PRFileMap* _md_OpenAnonFileMap(
• 2047:  #define _PR_MD_OPEN_ANON_FILE_MAP _md_OpenAnonFileMap

• 52:   * Our hash table resolves collisions by open addressing with

• 71:   virtual PRStatus Open(const char *name, PRIntn flags, PRIntn mode);

• 61:   open = PR_TRANSMITFILE_KEEP_OPEN, /* socket is left open after file
• 98:   virtual PRStatus Open(const char *name, PRIntn flags, PRIntn mode) = 0;

• 113:   PRStatus Open(const char *name, PRIntn flags, PRIntn mode);

• 67:  PRStatus RCFileIO::Open(const char *filename, PRIntn flags, PRIntn mode)
• 69:   fd = PR_Open(filename, flags, mode);
• 71:  } /* RCFileIO::Open */

• 83:   sg_okay, sg_open, sg_close, sg_delete, sg_write, sg_seek} Problem;
• 186:  ** 4) Reopens the file
• 218:   problem = sg_open;
• 219:   rv = file.Open(filename, PR_RDWR|PR_CREATE_FILE, 0666);
• 240:   problem = sg_open;
• 241:   rv = file.Open(filename, PR_RDWR, 0666);
• 321:   const char *where[] = {"okay", "open", "close", "delete", "write", "seek"};

• 52:   rv = fd.Open("filio.dat", PR_CREATE_FILE, 0666);

• 187:  PRStatus RCNetStreamIO::Open(const char*, PRIntn, PRIntn)

• 82:   PRfilebuf *open(const char *name, int mode, int flags);
• 85:   int is_open() const {return (_fd != 0);}
• 90:   PRBool _opened;
• 108:   int is_open(){return rdbuf()->is_open();}
• 109:   void open(const char *, int mode=ios::in, int flags= 0);
• 127:   int is_open(){return rdbuf()->is_open();}
• 128:   void open(const char *, int =ios::out, int = 0);
• 146:   int is_open() { return rdbuf()->is_open(); }
• 147:   void open(const char *, int, int = 0);

• 87:  _opened(PR_FALSE),
• 95:  _opened(PR_FALSE),
• 102:  _opened(PR_FALSE),
• 110:   if (_opened){
• 119:  PRfilebuf::open(const char *name, int mode, int flags)
• 122:   return 0; // error if already open
• 157:   _fd = PR_Open(name, PRmode, PRmode);
• 159:   _fd = PR_Open(name, PRmode, flags);
• 163:   _opened = PR_TRUE;
• 185:   _opened = PR_FALSE;
• 242:   if (is_open() && (ebuf()))
• 358:   if (!rdbuf()->open(name, (mode|ios::in), flags))
• 375:   if ((is_open()) || (!(rdbuf()->setbuf(ptr, len)))){
• 390:  PRifstream::open(const char * name, int mode, int flags)
• 392:   if (is_open() || !(rdbuf()->open(name, (mode|ios::in), flags)))
• 424:   if (!rdbuf()->open(name, (mode|ios::out), flags))
• 441:   if ((is_open()) || (!(rdbuf()->setbuf(ptr, len)))){
• 456:  PRofstream::open(const char * name, int mode, int flags)
• 458:   if (is_open() || !(rdbuf()->open(name, (mode|ios::out), flags)))
• 494:   if (!rdbuf()->open(name, (mode|(ios::in|ios::out)), flags))
• 513:   if ((is_open()) || (!(rdbuf()->setbuf(ptr, len)))){
• 528:  PRfstream::open(const char * name, int mode, int flags)
• 530:   if (is_open() || !(rdbuf()->open(name, (mode|(ios::in|ios::out)), flags)))

• 77:   virtual void CloseMorkNode(morkEnv* ev); // CloseAtomAidMap() only if open
• 206:   virtual void CloseMorkNode(morkEnv* ev); // CloseAtomBodyMap() only if open

• 66:  FILE* mork_fileopen(const char* name, const char* mode)
• 79:   descriptor = sopen(name, access, SH_DENYNO, pmode);
• 81:   return fdopen(descriptor, mode);

• 66:   // mork_access mNode_Access; // kOpen, kClosing, kShut, or kDead

• 77:   if ( mev->IsOpenNode() )
• 121:   if ( this->IsOpenNode() )
• 137:   err = morkEnv_kNonOpenNodeError;
• 254:  orkinEnv::IsOpenMdbObject(nsIMdbEnv* mev, mdb_bool* outOpen)
• 256:   return this->Handle_IsOpenMdbObject(mev, outOpen);

• 73:  morkObject::CloseMorkNode(morkEnv* ev) // CloseObject() only if open
• 75:   if ( this->IsOpenNode() )
• 205:  morkObject::IsOpenMdbObject(nsIMdbEnv* mev, mdb_bool* outOpen)
• 207:   *outOpen = IsOpenNode();

• 142:   NS_IMETHOD IsOpenMdbObject(nsIMdbEnv* ev, mdb_bool* outOpen);

• 140:   // mork_access mNode_Access; // kOpen, kClosing, kShut, or kDead

• 437:  morkProbeMap::CloseMorkNode(morkEnv* ev) // CloseMap() only if open
• 439:   if ( this->IsOpenNode() )

• 259:   // mork_access mNode_Access; // kOpen, kClosing, kShut, or kDead
• 321:   virtual void CloseMorkNode(morkEnv* ev); // CloseZone() only if open

• 88:  morkSortingRowCursor::CloseMorkNode(morkEnv* ev) // CloseSortingRowCursor() only if open
• 90:   if ( this->IsOpenNode() )
• 194:   if ( sorting->IsOpenNode() )
• 227:   sorting->NonOpenNodeError(ev);

• 61:   // mork_access mNode_Access; // kOpen, kClosing, kShut, or kDead
• 90:   NS_IMETHOD IsOpenMdbObject(nsIMdbEnv* ev, mdb_bool* outOpen);
• 119:   virtual void CloseMorkNode(morkEnv* ev); // CloseCursor() only if open

• 228:  morkNode::CloseMorkNode(morkEnv* ev) // CloseNode() only if open
• 230:   if ( this->IsOpenNode() )
• 251:   if ( IsNode() && IsOpenNode() )
• 271:  // void CloseMorkNode(morkEnv* ev) = 0; // CloseNode() only if open
• 273:   // which must do NOTHING at all when IsOpenNode() is not true. Otherwise,
• 285:  , mNode_Access( morkAccess_kOpen )
• 299:  , mNode_Access( morkAccess_kOpen )
• 316:  , mNode_Access( morkAccess_kOpen )
• 342:  morkNode::NonOpenNodeError(morkEnv* ev) const // when IsOpenNode() is false
• 344:   ev->NewError("non-open-morkNode");
• 559:   if ( this->IsOpenNode() )
• 658:  morkNode::GetNodeAccessAsString() const // e.g. "open", "shut", etc.
• 663:   case morkAccess_kOpen: outString = "open"; break;

• 66:  morkArray::CloseMorkNode(morkEnv* ev) // CloseTable() only if open
• 68:   if ( this->IsOpenNode() )

• 122:   mork_access mNode_Access; // kOpen, kClosing, kShut, or kDead
• 174:   virtual void CloseMorkNode(morkEnv* ev); // CloseNode() only if open
• 177:   // which must do NOTHING at all when IsOpenNode() is not true. Otherwise,
• 202:   void NonOpenNodeError(morkEnv* ev) const; // call when IsOpenNode() is false
• 228:   const char* GetNodeAccessAsString() const; // e.g. "open", "shut", etc.
• 236:   mork_bool IsOpenNode() const
• 237:   { return mNode_Access == morkAccess_kOpen; }
• 248:   mork_bool IsOpenOrClosingNode() const
• 249:   { return IsOpenNode() || IsClosingNode(); }
• 252:   { return ( IsOpenNode() || IsShutNode() || IsClosingNode() ); }

• 72:   // mork_access mNode_Access; // kOpen, kClosing, kShut, or kDead
• 105:   virtual void CloseMorkNode(morkEnv* ev); // CloseSpace() only if open
• 125:   static void NonAsciiSpaceScopeName(morkEnv* ev);

• 215:  orkinFile::IsOpenMdbObject(nsIMdbEnv* mev, mdb_bool* outOpen)
• 217:   return this->Handle_IsOpenMdbObject(mev, outOpen);

• 144:   NS_IMETHOD IsOpenMdbObject(nsIMdbEnv* ev, mdb_bool* outOpen);

• 92:  morkSearchRowCursor::CloseMorkNode(morkEnv* ev) // CloseSearchRowCursor() only if open
• 94:   if ( this->IsOpenNode() )

• 69:   // mork_access mNode_Access; // kOpen, kClosing, kShut, or kDead
• 87:   mork_u1 mFile_IoOpen; // 'O' => io stream is open (& needs a close)
• 99:   virtual void CloseMorkNode(morkEnv* ev); // CloseFile() only if open
• 119:   static morkFile* OpenOldFile(morkEnv* ev, nsIMdbHeap* ioHeap,
• 123:   // returned should be open and ready for use, and presumably positioned
• 125:   // files must be opened is considered a subclass specific detail, and
• 134:   // files must be opened is considered a subclass specific detail, and
• 143:   mork_bool FileIoOpen() const { return mFile_IoOpen == 'O'; }
• 148:   void SetFileIoOpen(mork_bool b) { mFile_IoOpen = (mork_u1) ((b)? 'O' : 0); }
• 152:   mork_bool IsOpenActiveAndMutableFile() const
• 153:   { return ( IsOpenNode() && FileActive() && !FileFrozen() ); }
• 154:   // call IsOpenActiveAndMutableFile() before writing a file
• 156:   mork_bool IsOpenAndActiveFile() const
• 157:   { return ( this->IsOpenNode() && this->FileActive() ); }
• 158:   // call IsOpenAndActiveFile() before using a file
• 173:   // call NewFileDownError() when either IsOpenAndActiveFile()
• 174:   // is false, or when IsOpenActiveAndMutableFile() is false.
• 249:   virtual void CloseMorkNode(morkEnv* ev); // CloseStdioFile() only if open
• 270:  public: // compatible with the morkFile::OpenOldFile() entry point
• 272:   static morkStdioFile* OpenOldStdioFile(morkEnv* ev, nsIMdbHeap* ioHeap,
• 322:   // calls OpenStdio() after construction
• 329:   void OpenStdio(morkEnv* ev, const char* inName, const char* inMode);
• 330:   // Open a new FILE with name inName, using mode flags from inMode.
• 340:   // Close the stream io if both and FileActive() and FileIoOpen(), but
• 344:   // because FileIoOpen() is false.

• 68:  morkHandle::CloseMorkNode(morkEnv* ev) // CloseHandle() only if open
• 70:   if ( this->IsOpenNode() )
• 165:  void morkHandle::NonOpenObjectError(morkEnv* ev) const
• 167:   ev->NewError("non-open mHandle_Object");
• 182:   if ( this->IsOpenNode() )
• 185:   this->NonOpenNodeError(ev);
• 199:   ( inClosedOkay || this->IsOpenNode() ) )
• 208:   if ( inClosedOkay || obj->IsOpenNode() )
• 216:   this->NonOpenObjectError(ev);
• 426:   if ( this->IsNode() && this->IsOpenNode() )
• 433:   if ( object && object->IsNode() && object->IsOpenNode() )
• 444:  morkHandle::Handle_IsOpenMdbObject(nsIMdbEnv* mev, mdb_bool* outOpen)
• 449:   MORK_ASSERT(outOpen);
• 450:   if ( outOpen )
• 451:   *outOpen = this->IsOpenNode();

• 67:   // mork_access mNode_Access; // kOpen, kClosing, kShut, or kDead

• 104:  morkBuilder::CloseMorkNode(morkEnv* ev) // CloseBuilder() only if open
• 106:   if ( this->IsOpenNode() )

• 212:  orkinThumb::IsOpenMdbObject(nsIMdbEnv* mev, mdb_bool* outOpen)
• 214:   return this->Handle_IsOpenMdbObject(mev, outOpen);

• 142:   NS_IMETHOD IsOpenMdbObject(nsIMdbEnv* ev, mdb_bool* outOpen);

• 243:  orkinSorting::IsOpenMdbObject(nsIMdbEnv* mev, mdb_bool* outOpen)
• 245:   return this->Handle_IsOpenMdbObject(mev, outOpen);

• 76:  #define morkEnv_kNonOpenNodeError NS_ERROR_FAILURE
• 92:   // mork_access mNode_Access; // kOpen, kClosing, kShut, or kDead
• 126:   virtual void CloseMorkNode(morkEnv* ev); // CloseEnv() only if open

• 301:  orkinCell::IsOpenMdbObject(nsIMdbEnv* mev, mdb_bool* outOpen)
• 303:   return this->Handle_IsOpenMdbObject(mev, outOpen);

• 85:  morkTableRowCursor::CloseMorkNode(morkEnv* ev) // CloseTableRowCursor() only if open
• 87:   if ( this->IsOpenNode() )
• 446:   if ( table->IsOpenNode() )
• 475:   table->NonOpenNodeError(ev);
• 493:   if ( table->IsOpenNode() )
• 526:   table->NonOpenNodeError(ev);

• 117:  **| 3) idHex:scopeName (mMid_Oid.mOid_Id <- idHex, mMid_Buf <- scopeName)
• 241:   // mork_access mNode_Access; // kOpen, kClosing, kShut, or kDead
• 332:   virtual void CloseMorkNode(morkEnv* ev); // CloseParser() only if open

• 68:  morkIntMap::CloseMorkNode(morkEnv* ev) // CloseIntMap() only if open
• 70:   if ( this->IsOpenNode() )
• 177:  morkPointerMap::CloseMorkNode(morkEnv* ev) // ClosePointerMap() only if open
• 179:   if ( this->IsOpenNode() )

• 145:   NS_IMETHOD IsOpenMdbObject(nsIMdbEnv* ev, mdb_bool* outOpen);

• 293:  orkinRow::IsOpenMdbObject(nsIMdbEnv* mev, mdb_bool* outOpen)
• 295:   return this->Handle_IsOpenMdbObject(mev, outOpen);

• 77:   // mork_access mNode_Access; // kOpen, kClosing, kShut, or kDead
• 94:   virtual void CloseMorkNode(morkEnv* ev); // CloseObject() only if open
• 131:   NS_IMETHOD IsOpenMdbObject(nsIMdbEnv* ev, mdb_bool* outOpen);

• 100:  morkSorting::CloseMorkNode(morkEnv* ev) /*i*/ // CloseSorting() only if open
• 102:   if ( this->IsOpenNode() )

• 65:   virtual void CloseMorkNode(morkEnv* ev); // CloseIntMap() only if open
• 125:   virtual void CloseMorkNode(morkEnv* ev); // ClosePointerMap() only if open

• 80:  morkRowObject::CloseMorkNode(morkEnv* ev) // CloseRowObject() only if open
• 82:   if ( this->IsOpenNode() )

• 76:  morkSpace::CloseMorkNode(morkEnv* ev) // CloseSpace() only if open
• 78:   if ( this->IsOpenNode() )
• 154:  morkSpace::NonAsciiSpaceScopeName(morkEnv* ev)

• 94:   // mork_access mNode_Access; // kOpen, kClosing, kShut, or kDead
• 138:   virtual void CloseMorkNode(morkEnv* ev); // CloseRowSpace() only if open

• 88:  morkAtomSpace::CloseMorkNode(morkEnv* ev) // CloseAtomSpace() only if open
• 90:   if ( this->IsOpenNode() )

• 74:   // mork_access mNode_Access; // kOpen, kClosing, kShut, or kDead

• 145:   NS_IMETHOD IsOpenMdbObject(nsIMdbEnv* ev, mdb_bool* outOpen);

• 78:  morkFile::CloseMorkNode(morkEnv* ev) // CloseFile() only if open
• 80:   if ( this->IsOpenNode() )
• 93:   MORK_ASSERT(mFile_IoOpen==0);
• 103:  , mFile_IoOpen( 0 )
• 133:   mFile_IoOpen = 0;
• 168:  morkFile::OpenOldFile(morkEnv* ev, nsIMdbHeap* ioHeap,
• 172:   // returned should be open and ready for use, and presumably positioned
• 174:   // files must be opened is considered a subclass specific detail, and
• 177:   return morkStdioFile::OpenOldStdioFile(ev, ioHeap, inFilePath, inFrozen);
• 187:   // files must be opened is considered a subclass specific detail, and
• 244:  // call NewFileDownError() when either IsOpenAndActiveFile()
• 245:  // is false, or when IsOpenActiveAndMutableFile() is false.
• 247:   if ( this->IsOpenNode() )
• 262:   ev->NewError("file not open");
• 407:  morkStdioFile::CloseMorkNode(morkEnv* ev) // CloseStdioFile() only if open
• 409:   if ( this->IsOpenNode() )
• 432:   if ( mStdioFile_File && this->FileActive() && this->FileIoOpen() )
• 455:  morkStdioFile::OpenOldStdioFile(morkEnv* ev, nsIMdbHeap* ioHeap,
• 527:   if ( this->IsOpenAndActiveFile() )
• 541:   this->SetFileIoOpen(morkBool_kFalse);
• 544:   file = MORK_FILEOPEN(name, "wb+"); // open for write, discarding old content
• 549:   this->SetFileIoOpen(morkBool_kTrue);
• 587:   if ( this->IsOpenAndActiveFile() )
• 629:   if ( this->IsOpenAndActiveFile() )
• 655:   if ( this->IsOpenAndActiveFile() )
• 684:   if ( this->IsOpenOrClosingNode() && this->FileActive() )
• 712:   if ( this->IsOpenActiveAndMutableFile() )
• 738:   if ( this->IsOpenOrClosingNode() && this->FileActive() )
• 792:   // calls OpenStdio() after construction
• 797:   this->OpenStdio(ev, inName, inMode);
• 812:  morkStdioFile::OpenStdio(morkEnv* ev, const char* inName, const char* inMode)
• 813:   // Open a new FILE with name inName, using mode flags from inMode.
• 822:   if ( this->IsOpenNode() )
• 826:   this->SetFileIoOpen(morkBool_kFalse);
• 832:   FILE* file = MORK_FILEOPEN(inName, inMode);
• 837:   this->SetFileIoOpen(morkBool_kTrue);
• 862:   if ( this->IsOpenNode() )
• 868:   this->SetFileIoOpen(morkBool_kFalse);
• 888:   // Close the stream io if both and FileActive() and FileIoOpen(), but
• 892:   // because FileIoOpen() is false.
• 894:   if ( mStdioFile_File && this->FileActive() && this->FileIoOpen() )
• 902:   this->SetFileIoOpen(morkBool_kFalse);
• 914:   if ( mStdioFile_File && FileActive() && FileIoOpen() )

• 74:   // mork_access mNode_Access; // kOpen, kClosing, kShut, or kDead
• 90:   virtual void CloseMorkNode(morkEnv* ev); // CloseFactory() only if open
• 97:   NS_IMETHOD OpenOldFile(nsIMdbEnv* ev, nsIMdbHeap* ioHeap,
• 102:   // returned should be open and ready for use, and presumably positioned
• 104:   // files must be opened is considered a subclass specific detail, and
• 114:   // files must be opened is considered a subclass specific detail, and
• 137:   NS_IMETHOD CanOpenFilePort(
• 142:   mdb_bool* outCanOpen, // whether OpenFilePort() might succeed
• 145:   NS_IMETHOD OpenFilePort(
• 148:   // const char* inFilePath, // the file to open for readonly import
• 150:   const mdbOpenPolicy* inOpenPolicy, // runtime policies for using db
• 151:   nsIMdbThumb** acqThumb); // acquire thumb for incremental port open
• 153:   // then call nsIMdbFactory::ThumbToOpenPort() to get the port instance.
• 155:   NS_IMETHOD ThumbToOpenPort( // redeeming a completed thumb from OpenFilePort()
• 157:   nsIMdbThumb* ioThumb, // thumb from OpenFilePort() with done status
• 162:   NS_IMETHOD CanOpenFileStore(
• 167:   mdb_bool* outCanOpenAsStore, // whether OpenFileStore() might succeed
• 168:   mdb_bool* outCanOpenAsPort, // whether OpenFilePort() might succeed
• 171:   NS_IMETHOD OpenFileStore( // open an existing database
• 174:   // const char* inFilePath, // the file to open for general db usage
• 176:   const mdbOpenPolicy* inOpenPolicy, // runtime policies for using db
• 177:   nsIMdbThumb** acqThumb); // acquire thumb for incremental store open
• 179:   // then call nsIMdbFactory::ThumbToOpenStore() to get the store instance.
• 182:   ThumbToOpenStore( // redeem completed thumb from OpenFileStore()
• 184:   nsIMdbThumb* ioThumb, // thumb from OpenFileStore() with done status
• 192:   const mdbOpenPolicy* inOpenPolicy, // runtime policies for using db
• 225:   mork_bool CanOpenMorkTextFile(morkEnv* ev, nsIMdbFile* ioFile);

• 243:  orkinStore::IsOpenMdbObject(nsIMdbEnv* mev, mdb_bool* outOpen)
• 245:   return this->Handle_IsOpenMdbObject(mev, outOpen);

• 64:   virtual void CloseMorkNode(morkEnv* ev); // CloseRowObject() only if open

• 68:  morkStream::CloseMorkNode(morkEnv* ev) // CloseStream() only if open
• 70:   if ( this->IsOpenNode() )
• 141:   this->SetFileIoOpen(morkBool_kTrue);
• 346:   // system, because the file ioThief intends to reopen the file in order
• 349:   // from Path() in order to know which file to reopen. If Steal() is
• 393:   if ( this->IsOpenAndActiveFile() && file )
• 410:   if ( this->IsOpenAndActiveFile() && file )
• 470:   if ( this->IsOpenAndActiveFile() && file )
• 513:   if ( this->IsOpenAndActiveFile() && file )
• 516:   if ( end ) // file is open for read access?
• 602:   if ( this->IsOpenOrClosingNode() && this->FileActive() && file )
• 673:   if ( this->IsOpenActiveAndMutableFile() && file )
• 676:   if ( end ) // file is open for write access?
• 773:   if ( this->IsOpenOrClosingNode() && this->FileActive() && file )
• 793:   if ( this->IsOpenAndActiveFile() && file )
• 846:   if ( this->IsOpenOrClosingNode() && this->FileActive() && file )

• 115:   virtual void CloseMorkNode(morkEnv* ev); // CloseStream() only if open
• 140:   // system, because the file ioThief intends to reopen the file in order
• 143:   // from Path() in order to know which file to reopen. If Steal() is

• 72:  morkRowMap::CloseMorkNode(morkEnv* ev) // CloseRowMap() only if open
• 74:   if ( this->IsOpenNode() )
• 199:  morkRowProbeMap::CloseMorkNode(morkEnv* ev) // CloseRowProbeMap() only if open
• 201:   if ( this->IsOpenNode() )

• 150:   NS_IMETHOD IsOpenMdbObject(nsIMdbEnv* ev, mdb_bool* outOpen);

• 84:  morkCellObject::CloseMorkNode(morkEnv* ev) // CloseCellObject() only if open
• 86:   if ( this->IsOpenNode() )

• 64:  morkBead::CloseMorkNode(morkEnv* ev) // CloseBead() only if open
• 66:   if ( this->IsOpenNode() )
• 137:  morkBeadMap::CloseMorkNode(morkEnv* ev) // CloseBeadMap() only if open
• 139:   if ( this->IsOpenNode() )
• 318:  morkBeadProbeMap::CloseMorkNode(morkEnv* ev) // CloseBeadProbeMap() if open
• 320:   if ( this->IsOpenNode() )

• 104:  FILE* mork_fileopen(const char* name, const char* mode);
• 105:  #define MORK_FILEOPEN(file, how) mork_fileopen(file, how)
• 107:  #define MORK_FILEOPEN(file, how) fopen(file, how)

• 80:  morkAtomAidMap::CloseMorkNode(morkEnv* ev) // CloseAtomAidMap() only if open
• 82:   if ( this->IsOpenNode() )
• 275:  morkAtomBodyMap::CloseMorkNode(morkEnv* ev) // CloseAtomBodyMap() only if open
• 277:   if ( this->IsOpenNode() )

• 92:  morkTable::CloseMorkNode(morkEnv* ev) /*i*/ // CloseTable() only if open
• 94:   if ( this->IsOpenNode() )

• 63:   // mork_access mNode_Access; // kOpen, kClosing, kShut, or kDead
• 76:   virtual void CloseMorkNode(morkEnv* ev); // CloseYarn() only if open

• 61:   // mork_access mNode_Access; // kOpen, kClosing, kShut, or kDead

• 64:  morkYarn::CloseMorkNode(morkEnv* ev) /*i*/ // CloseYarn() only if open
• 66:   if ( this->IsOpenNode() )

• 142:   NS_IMETHOD IsOpenMdbObject(nsIMdbEnv* ev, mdb_bool* outOpen);

• 164:  #define morkAccess_kOpen 'o'

• 71:   // mork_access mNode_Access; // kOpen, kClosing, kShut, or kDead

• 88:  morkThumb::CloseMorkNode(morkEnv* ev) // CloseThumb() only if open
• 90:   if ( this->IsOpenNode() )
• 251:  morkThumb::Make_OpenFileStore(morkEnv* ev, nsIMdbHeap* ioHeap,
• 266:   morkThumb_kMagic_OpenFileStore);
• 395:   case morkThumb_kMagic_OpenFilePort: // 1 /* factory method */
• 396:   this->DoMore_OpenFilePort(ev); break;
• 398:   case morkThumb_kMagic_OpenFileStore: // 2 /* factory method */
• 399:   this->DoMore_OpenFileStore(ev); break;
• 458:  morkThumb::ThumbToOpenStore(morkEnv* ev)
• 459:  // for orkinFactory::ThumbToOpenStore() after OpenFileStore()
• 465:  void morkThumb::DoMore_OpenFilePort(morkEnv* ev)
• 470:  void morkThumb::DoMore_OpenFileStore(morkEnv* ev)

• 104:  morkRowSpace::CloseMorkNode(morkEnv* ev) // CloseRowSpace() only if open
• 106:   if ( this->IsOpenNode() )

• 85:   // mork_access mNode_Access; // kOpen, kClosing, kShut, or kDead
• 336:   virtual void CloseMorkNode(morkEnv* ev); // CloseProbeMap() only if open

• 138:   if ( table && table->IsOpenNode() )
• 239:  orkinTableRowCursor::IsOpenMdbObject(nsIMdbEnv* mev, mdb_bool* outOpen)
• 241:   return this->Handle_IsOpenMdbObject(mev, outOpen);

• 88:  morkParser::CloseMorkNode(morkEnv* ev) // CloseParser() only if open
• 90:   if ( this->IsOpenNode() )
• 217:   if ( this->IsOpenNode() )
• 227:   this->NonOpenNodeError(ev);
• 1488:   if ( s && s->IsNode() && s->IsOpenNode() )
• 1563:   if ( this->IsNode() && this->GoodParserTag() && this->IsOpenNode() )

• 88:   // mork_access mNode_Access; // kOpen, kClosing, kShut, or kDead
• 123:   virtual void CloseMorkNode(morkEnv* ev); // CloseSorting() if open

• 62:  void morkZone::CloseMorkNode(morkEnv* ev) // CloseZone() only if open
• 64:   if ( this->IsOpenNode() )

• 150:   NS_IMETHOD IsOpenMdbObject(nsIMdbEnv* ev, mdb_bool* outOpen);

• 67:   virtual void CloseMorkNode(morkEnv* ev); // CloseRowMap() only if open
• 153:   virtual void CloseMorkNode(morkEnv* ev); // CloseRowProbeMap() only if open

• 56:  #define morkThumb_kMagic_OpenFilePort 1 /* factory method */
• 57:  #define morkThumb_kMagic_OpenFileStore 2 /* factory method */
• 82:   // mork_access mNode_Access; // kOpen, kClosing, kShut, or kDead
• 119:   morkBuilder* mThumb_Builder; // strong ref to builder (for store open)
• 127:   virtual void CloseMorkNode(morkEnv* ev); // CloseThumb() only if open
• 156:   void DoMore_OpenFilePort(morkEnv* ev);
• 157:   void DoMore_OpenFileStore(morkEnv* ev);
• 173:   morkStore* ThumbToOpenStore(morkEnv* ev);
• 174:   // for orkinFactory::ThumbToOpenStore() after OpenFileStore()
• 178:   static morkThumb* Make_OpenFileStore(morkEnv* ev,

• 119:   // mork_access mNode_Access; // kOpen, kClosing, kShut, or kDead
• 498:   virtual void CloseMorkNode(morkEnv* ev); // CloseTable() if open

• 142:   NS_IMETHOD IsOpenMdbObject(nsIMdbEnv* ev, mdb_bool* outOpen);

• 193:   if ( f && f->IsNode() && f->IsOpenNode() && f->IsFactory() )
• 196:   if ( fenv && fenv->IsNode() && fenv->IsOpenNode() && fenv->IsEnv() )
• 297:  orkinFactory::IsOpenMdbObject(nsIMdbEnv* mev, mdb_bool* outOpen)
• 299:   return this->Handle_IsOpenMdbObject(mev, outOpen);
• 309:  orkinFactory::OpenOldFile(nsIMdbEnv* mev, nsIMdbHeap* ioHeap,
• 314:   // returned should be open and ready for use, and presumably positioned
• 316:   // files must be opened is considered a subclass specific detail, and
• 330:   file = morkFile::OpenOldFile(ev, ioHeap, inFilePath, inFrozen);
• 348:   // files must be opened is considered a subclass specific detail, and
• 484:  orkinFactory::CanOpenFilePort(
• 489:   mdb_bool* outCanOpen, // whether OpenFilePort() might succeed
• 497:   mdb_bool canOpenAsPort = morkBool_kFalse;
• 502:   if ( ioFile && outCanOpen )
• 504:   canOpenAsPort = this->CanOpenMorkTextFile(ev, ioFile);
• 512:   if ( outCanOpen )
• 513:   *outCanOpen = canOpenAsPort;
• 519:  orkinFactory::OpenFilePort(
• 522:   // const char* inFilePath, // the file to open for readonly import
• 524:   const mdbOpenPolicy* inOpenPolicy, // runtime policies for using db
• 534:   if ( ioFile && inOpenPolicy && acqThumb )
• 547:  // then call nsIMdbFactory::ThumbToOpenPort() to get the port instance.
• 550:  orkinFactory::ThumbToOpenPort( // redeeming a completed thumb from OpenFilePort()
• 552:   nsIMdbThumb* ioThumb, // thumb from OpenFilePort() with done status
• 564:   morkStore* store = thumb->ThumbToOpenStore(ev);
• 587:  orkinFactory::CanOpenMorkTextFile(morkEnv* ev,
• 626:  orkinFactory::CanOpenFileStore(
• 631:   mdb_bool* outCanOpenAsStore, // whether OpenFileStore() might succeed
• 632:   mdb_bool* outCanOpenAsPort, // whether OpenFilePort() might succeed
• 635:   mdb_bool canOpenAsStore = morkBool_kFalse;
• 636:   mdb_bool canOpenAsPort = morkBool_kFalse;
• 646:   if ( ioFile && outCanOpenAsStore )
• 649:   canOpenAsStore = this->CanOpenMorkTextFile(ev, ioFile);
• 650:   canOpenAsPort = canOpenAsStore;
• 657:   if ( outCanOpenAsStore )
• 658:   *outCanOpenAsStore = canOpenAsStore;
• 660:   if ( outCanOpenAsPort )
• 661:   *outCanOpenAsPort = canOpenAsPort;
• 667:  orkinFactory::OpenFileStore( // open an existing database
• 670:   // const char* inFilePath, // the file to open for general db usage
• 672:   const mdbOpenPolicy* inOpenPolicy, // runtime policies for using db
• 684:   if ( ioFile && inOpenPolicy && acqThumb )
• 692:   mork_bool frozen = morkBool_kFalse; // open store mutable access
• 693:   if ( store->OpenStoreFile(ev, frozen, ioFile, inOpenPolicy) )
• 695:   morkThumb* thumb = morkThumb::Make_OpenFileStore(ev, ioHeap, store);
• 715:  // then call nsIMdbFactory::ThumbToOpenStore() to get the store instance.
• 718:  orkinFactory::ThumbToOpenStore( // redeem completed thumb from OpenFileStore()
• 720:   nsIMdbThumb* ioThumb, // thumb from OpenFileStore() with done status
• 732:   morkStore* store = thumb->ThumbToOpenStore(ev);
• 759:   const mdbOpenPolicy* inOpenPolicy, // runtime policies for using db
• 771:   if ( ioFile && inOpenPolicy && acqStore && ioHeap )
• 783:   if ( store->CreateStoreFile(ev, ioFile, inOpenPolicy) )

• 253:  orkinRowCellCursor::IsOpenMdbObject(nsIMdbEnv* mev, mdb_bool* outOpen)
• 255:   return this->Handle_IsOpenMdbObject(mev, outOpen);

• 87:  morkFactory::CloseMorkNode(morkEnv* ev) /*i*/ // CloseFactory() only if open
• 89:   if ( this->IsOpenNode() )
• 178:   if (IsNode() && IsOpenNode() && IsFactory() )
• 181:   if ( fenv && fenv->IsNode() && fenv->IsOpenNode() && fenv->IsEnv() )
• 204:  morkFactory::OpenOldFile(nsIMdbEnv* mev, nsIMdbHeap* ioHeap,
• 209:   // returned should be open and ready for use, and presumably positioned
• 211:   // files must be opened is considered a subclass specific detail, and
• 222:   file = morkFile::OpenOldFile(ev, ioHeap, inFilePath, inFrozen);
• 240:   // files must be opened is considered a subclass specific detail, and
• 346:  morkFactory::CanOpenFilePort(
• 351:   mdb_bool* outCanOpen, // whether OpenFilePort() might succeed
• 359:   mdb_bool canOpenAsPort = morkBool_kFalse;
• 363:   if ( ioFile && outCanOpen )
• 365:   canOpenAsPort = this->CanOpenMorkTextFile(ev, ioFile);
• 373:   if ( outCanOpen )
• 374:   *outCanOpen = canOpenAsPort;
• 380:  morkFactory::OpenFilePort(
• 383:   // const char* inFilePath, // the file to open for readonly import
• 385:   const mdbOpenPolicy* inOpenPolicy, // runtime policies for using db
• 395:   if ( ioFile && inOpenPolicy && acqThumb )
• 408:  // then call nsIMdbFactory::ThumbToOpenPort() to get the port instance.
• 411:  morkFactory::ThumbToOpenPort( // redeeming a completed thumb from OpenFilePort()
• 413:   nsIMdbThumb* ioThumb, // thumb from OpenFilePort() with done status
• 424:   morkStore* store = thumb->ThumbToOpenStore(ev);
• 447:  morkFactory::CanOpenMorkTextFile(morkEnv* ev,
• 486:  morkFactory::CanOpenFileStore(
• 491:   mdb_bool* outCanOpenAsStore, // whether OpenFileStore() might succeed
• 492:   mdb_bool* outCanOpenAsPort, // whether OpenFilePort() might succeed
• 495:   mdb_bool canOpenAsStore = morkBool_kFalse;
• 496:   mdb_bool canOpenAsPort = morkBool_kFalse;
• 505:   if ( ioFile && outCanOpenAsStore )
• 508:   canOpenAsStore = this->CanOpenMorkTextFile(ev, ioFile);
• 509:   canOpenAsPort = canOpenAsStore;
• 516:   if ( outCanOpenAsStore )
• 517:   *outCanOpenAsStore = canOpenAsStore;
• 519:   if ( outCanOpenAsPort )
• 520:   *outCanOpenAsPort = canOpenAsPort;
• 526:  morkFactory::OpenFileStore( // open an existing database
• 529:   // const char* inFilePath, // the file to open for general db usage
• 531:   const mdbOpenPolicy* inOpenPolicy, // runtime policies for using db
• 542:   if ( ioFile && inOpenPolicy && acqThumb )
• 549:   mork_bool frozen = morkBool_kFalse; // open store mutable access
• 550:   if ( store->OpenStoreFile(ev, frozen, ioFile, inOpenPolicy) )
• 552:   morkThumb* thumb = morkThumb::Make_OpenFileStore(ev, ioHeap, store);
• 572:  // then call nsIMdbFactory::ThumbToOpenStore() to get the store instance.
• 575:  morkFactory::ThumbToOpenStore( // redeem completed thumb from OpenFileStore()
• 577:   nsIMdbThumb* ioThumb, // thumb from OpenFileStore() with done status
• 588:   morkStore* store = thumb->ThumbToOpenStore(ev);
• 615:   const mdbOpenPolicy* inOpenPolicy, // runtime policies for using db
• 626:   if ( ioFile && inOpenPolicy && acqStore && ioHeap )
• 637:   if ( store->CreateStoreFile(ev, ioFile, inOpenPolicy) )

• 68:  morkEnv::CloseMorkNode(morkEnv* ev) /*i*/ // CloseEnv() only if open
• 70:   if ( this->IsOpenNode() )
• 220:   if (savePool->IsOpenNode())

• 98:   // mork_access mNode_Access; // kOpen, kClosing, kShut, or kDead
• 129:   virtual void CloseMorkNode(morkEnv* ev); // CloseAtomSpace() only if open

• 75:   // mork_access mNode_Access; // kOpen, kClosing, kShut, or kDead
• 97:   virtual void CloseMorkNode(morkEnv* ev); // ClosePool() only if open

• 62:   // mork_access mNode_Access; // kOpen, kClosing, kShut, or kDead

• 136:  morkStore::CloseMorkNode(morkEnv* ev) // ClosePort() only if open
• 138:   if ( this->IsOpenNode() )
• 169:   if (IsOpenNode())
• 215:  , mStore_CanDirty( morkBool_kFalse ) // not until the store is open
• 657:  morkStore::OpenStoreFile(morkEnv* ev, mork_bool inFrozen,
• 660:   const mdbOpenPolicy* inOpenPolicy)
• 662:   MORK_USED_2(inOpenPolicy,inFrozen);
• 667:   // morkFile* file = morkFile::OpenOldFile(ev, mPort_Heap,
• 685:   const mdbOpenPolicy* inOpenPolicy)
• 687:   MORK_USED_1(inOpenPolicy);
• 1375:  morkStore::IsOpenMdbObject(nsIMdbEnv* mev, mdb_bool* outOpen)
• 1377:   *outOpen = IsOpenNode();

• 73:   // mork_access mNode_Access; // kOpen, kClosing, kShut, or kDead
• 93:   virtual void CloseMorkNode(morkEnv* ev); // CloseBead() only if open
• 140:   virtual void CloseMorkNode(morkEnv* ev); // CloseBeadMap() only if open
• 205:   virtual void CloseMorkNode(morkEnv* ev); // CloseBeadProbeMap() only if open

• 69:   virtual void CloseMorkNode(morkEnv* ev); // CloseNodeMap() only if open

• 92:  morkPool::CloseMorkNode(morkEnv* ev) // ClosePool() only if open
• 94:   if ( this->IsOpenNode() )

• 144:   NS_IMETHOD IsOpenMdbObject(nsIMdbEnv* ev, mdb_bool* outOpen);
• 520:   // mork_access mNode_Access; // kOpen, kClosing, kShut, or kDead
• 648:   virtual void CloseMorkNode(morkEnv* ev); // CloseStore() only if open
• 688:   mork_bool OpenStoreFile(morkEnv* ev, // return value equals ev->Good()
• 692:   const mdbOpenPolicy* inOpenPolicy);
• 697:   const mdbOpenPolicy* inOpenPolicy);

• 72:  morkNodeMap::CloseMorkNode(morkEnv* ev) // CloseNodeMap() only if open
• 74:   if ( this->IsOpenNode() )

• 145:   NS_IMETHOD IsOpenMdbObject(nsIMdbEnv* ev, mdb_bool* outOpen);

• 68:  morkCursor::CloseMorkNode(morkEnv* ev) // CloseCursor() only if open
• 70:   if ( this->IsOpenNode() )
• 161:  morkCursor::IsOpenMdbObject(nsIMdbEnv* mev, mdb_bool* outOpen)
• 163:   *outOpen = IsOpenNode();

• 221:  orkinPortTableCursor::IsOpenMdbObject(nsIMdbEnv* mev, mdb_bool* outOpen)
• 223:   return this->Handle_IsOpenMdbObject(mev, outOpen);

• 65:   // mork_access mNode_Access; // kOpen, kClosing, kShut, or kDead
• 85:   virtual void CloseMorkNode(morkEnv* ev); // CloseCellObject() only if open

• 84:  morkRowCellCursor::CloseMorkNode(morkEnv* ev) // CloseRowCellCursor() only if open
• 86:   if ( this->IsOpenNode() )

• 115:   mork_bool CanOpenMorkTextFile(morkEnv* ev,
• 154:   NS_IMETHOD IsOpenMdbObject(nsIMdbEnv* ev, mdb_bool* outOpen);
• 162:   NS_IMETHOD OpenOldFile(nsIMdbEnv* ev, nsIMdbHeap* ioHeap,
• 167:   // returned should be open and ready for use, and presumably positioned
• 169:   // files must be opened is considered a subclass specific detail, and
• 179:   // files must be opened is considered a subclass specific detail, and
• 202:   NS_IMETHOD CanOpenFilePort(
• 207:   mdb_bool* outCanOpen, // whether OpenFilePort() might succeed
• 210:   NS_IMETHOD OpenFilePort(
• 213:   // const char* inFilePath, // the file to open for readonly import
• 215:   const mdbOpenPolicy* inOpenPolicy, // runtime policies for using db
• 216:   nsIMdbThumb** acqThumb); // acquire thumb for incremental port open
• 218:   // then call nsIMdbFactory::ThumbToOpenPort() to get the port instance.
• 220:   NS_IMETHOD ThumbToOpenPort( // redeeming a completed thumb from OpenFilePort()
• 222:   nsIMdbThumb* ioThumb, // thumb from OpenFilePort() with done status
• 227:   NS_IMETHOD CanOpenFileStore(
• 232:   mdb_bool* outCanOpenAsStore, // whether OpenFileStore() might succeed
• 233:   mdb_bool* outCanOpenAsPort, // whether OpenFilePort() might succeed
• 236:   NS_IMETHOD OpenFileStore( // open an existing database
• 239:   // const char* inFilePath, // the file to open for general db usage
• 241:   const mdbOpenPolicy* inOpenPolicy, // runtime policies for using db
• 242:   nsIMdbThumb** acqThumb); // acquire thumb for incremental store open
• 244:   // then call nsIMdbFactory::ThumbToOpenStore() to get the store instance.
• 247:   ThumbToOpenStore( // redeem completed thumb from OpenFileStore()
• 249:   nsIMdbThumb* ioThumb, // thumb from OpenFileStore() with done status
• 257:   const mdbOpenPolicy* inOpenPolicy, // runtime policies for using db

• 239:  orkinTable::IsOpenMdbObject(nsIMdbEnv* mev, mdb_bool* outOpen)
• 241:   return this->Handle_IsOpenMdbObject(mev, outOpen);

• 76:   // mork_access mNode_Access; // kOpen, kClosing, kShut, or kDead
• 94:   virtual void CloseMorkNode(morkEnv* ev); // CloseHandle() only if open
• 137:   void NonOpenObjectError(morkEnv* ev) const;
• 161:   mdb_err Handle_IsOpenMdbObject(nsIMdbEnv* ev, mdb_bool* outOpen);

• 143:   NS_IMETHOD IsOpenMdbObject(nsIMdbEnv* ev, mdb_bool* outOpen);

• 67:   // mork_access mNode_Access; // kOpen, kClosing, kShut, or kDead

• 67:   // mork_access mNode_Access; // kOpen, kClosing, kShut, or kDead
• 205:   virtual void CloseMorkNode(morkEnv* ev); // CloseBuilder() only if open

• 104:  morkMap::CloseMorkNode(morkEnv* ev) // CloseMap() only if open
• 106:   if ( this->IsOpenNode() )

• 116:  morkWriter::CloseMorkNode(morkEnv* ev) // CloseTable() only if open
• 118:   if ( this->IsOpenNode() )
• 342:   if ( this->IsOpenNode() )
• 408:   this->NonOpenNodeError(ev);
• 508:   ioSpace->NonAsciiSpaceScopeName(ev);
• 515:   buf[ 0 ] = '('; // we always start with open paren
• 1500:   *p++ = '('; // we always start with open paren
• 1573:   *p++ = '<'; // we always start with open paren
• 1574:   *p++ = '('; // we always start with open paren
• 1617:   *p++ = '['; // we always start with open bracket
• 1618:   *p++ = '('; // we always start with open paren
• 1660:   *p++ = '<'; // we always start with open angle
• 1661:   *p++ = '('; // we always start with open paren
• 1879:   buf[ 0 ] = '('; // we always start with open paren
• 2019:   buf[ 0 ] = '('; // we always start with open paren

• 72:  morkPortTableCursor::CloseMorkNode(morkEnv* ev) // ClosePortTableCursor() only if open
• 74:   if ( this->IsOpenNode() )

• 148:  **| (which is in turn rather like a similar OpenDoc hash table).
• 158:   // mork_access mNode_Access; // kOpen, kClosing, kShut, or kDead
• 230:   virtual void CloseMorkNode(morkEnv* ev); // CloseMap() only if open
• 255:  public: // open utitity methods

• 165:  ** Each open SQLite database is represented by a pointer to an instance of
• 167:  ** pointer as an object. The [sqlite3_open()], [sqlite3_open16()], and
• 168:  ** [sqlite3_open_v2()] interfaces are its constructors, and [sqlite3_close()]
• 229:  ** If [sqlite3_close()] is invoked while a transaction is open,
• 234:  ** from [sqlite3_open()], [sqlite3_open16()], or
• 235:  ** [sqlite3_open_v2()], and not previously closed.
• 276:  ** The first parameter to [sqlite3_exec()] must be an valid and open
• 294:   sqlite3*, /* An open database */
• 328:  #define SQLITE_CANTOPEN 14 /* Unable to open the database file */
• 340:  #define SQLITE_NOTADB 26 /* File opened that is not a database file */
• 388:  ** CAPI3REF: Flags For File Open Operations {H10230} <H11120> <H12700>
• 391:  ** 3rd parameter to the [sqlite3_open_v2()] interface and
• 392:  ** in the 4th parameter to the xOpen method of the
• 395:  #define SQLITE_OPEN_READONLY 0x00000001
• 396:  #define SQLITE_OPEN_READWRITE 0x00000002
• 397:  #define SQLITE_OPEN_CREATE 0x00000004
• 398:  #define SQLITE_OPEN_DELETEONCLOSE 0x00000008
• 399:  #define SQLITE_OPEN_EXCLUSIVE 0x00000010
• 400:  #define SQLITE_OPEN_MAIN_DB 0x00000100
• 401:  #define SQLITE_OPEN_TEMP_DB 0x00000200
• 402:  #define SQLITE_OPEN_TRANSIENT_DB 0x00000400
• 403:  #define SQLITE_OPEN_MAIN_JOURNAL 0x00000800
• 404:  #define SQLITE_OPEN_TEMP_JOURNAL 0x00001000
• 405:  #define SQLITE_OPEN_SUBJOURNAL 0x00002000
• 406:  #define SQLITE_OPEN_MASTER_JOURNAL 0x00004000
• 407:  #define SQLITE_OPEN_NOMUTEX 0x00008000
• 408:  #define SQLITE_OPEN_FULLMUTEX 0x00010000
• 474:  ** CAPI3REF: OS Interface Open File Handle {H11110} <S20110>
• 476:  ** An [sqlite3_file] object represents an open file in the OS
• 481:  ** I/O operations on the open file.
• 485:   const struct sqlite3_io_methods *pMethods; /* Methods for an open file */
• 491:  ** Every file opened by the [sqlite3_vfs] xOpen method populates an
• 495:  ** against the open file represented by the [sqlite3_file] object.
• 518:  ** VFS implementations to directly control an open file using the
• 653:  ** SQLite will guarantee that the zFilename parameter to xOpen
• 660:  ** If the zFilename parameter is xOpen is a NULL pointer then xOpen
• 663:  ** flags parameter will include [SQLITE_OPEN_DELETEONCLOSE].
• 665:  ** The flags argument to xOpen() includes all bits set in
• 666:  ** the flags argument to [sqlite3_open_v2()]. Or if [sqlite3_open()]
• 667:  ** or [sqlite3_open16()] is used, then flags includes at least
• 668:  ** [SQLITE_OPEN_READWRITE] | [SQLITE_OPEN_CREATE].
• 669:  ** If xOpen() opens a file read-only then it sets *pOutFlags to
• 670:  ** include [SQLITE_OPEN_READONLY]. Other bits in *pOutFlags may be set.
• 672:  ** SQLite will also add one of the following flags to the xOpen()
• 673:  ** call, depending on the object being opened:
• 676:  ** <li> [SQLITE_OPEN_MAIN_DB]
• 677:  ** <li> [SQLITE_OPEN_MAIN_JOURNAL]
• 678:  ** <li> [SQLITE_OPEN_TEMP_DB]
• 679:  ** <li> [SQLITE_OPEN_TEMP_JOURNAL]
• 680:  ** <li> [SQLITE_OPEN_TRANSIENT_DB]
• 681:  ** <li> [SQLITE_OPEN_SUBJOURNAL]
• 682:  ** <li> [SQLITE_OPEN_MASTER_JOURNAL]
• 688:  ** the open of a journal file a no-op. Writes to this journal would
• 694:  ** SQLite might also add one of the following flags to the xOpen method:
• 697:  ** <li> [SQLITE_OPEN_DELETEONCLOSE]
• 698:  ** <li> [SQLITE_OPEN_EXCLUSIVE]
• 701:  ** The [SQLITE_OPEN_DELETEONCLOSE] flag means the file should be
• 702:  ** deleted when it is closed. The [SQLITE_OPEN_DELETEONCLOSE]
• 705:  ** The [SQLITE_OPEN_EXCLUSIVE] flag means the file should be opened
• 711:  ** argument to xOpen. The xOpen method does not have to
• 723:  ** is not large enough, [SQLITE_CANTOPEN] should be returned. Since this is
• 746:   int (*xOpen)(sqlite3_vfs*, const char *zName, sqlite3_file*,
• 751:   void *(*xDlOpen)(sqlite3_vfs*, const char *zFilename);
• 810:  ** invoke sqlite3_initialize() directly. For example, [sqlite3_open()]
• 812:  ** initialized when [sqlite3_open()] is called if it has not be initialized
• 894:  ** the database connection is created using [sqlite3_open()],
• 895:  ** [sqlite3_open16()], or [sqlite3_open_v2()].
• 1275:  ** [UPDATE] or [DELETE] statements since the [database connection] was opened.
• 1383:  ** an attempt is made to open a database table that another thread
• 1397:  ** is made to open the database for reading and the cycle repeats.
• 1543:   sqlite3 *db, /* An open database */
• 1716:  ** they are reported back as [SQLITE_CANTOPEN] or
• 1983:  ** CAPI3REF: Opening A New Database Connection {H12700} <S40200>
• 1985:  ** These routines open an SQLite database file whose name is given by the
• 1987:  ** sqlite3_open() and sqlite3_open_v2() and as UTF-16 in the native byte
• 1988:  ** order for sqlite3_open16(). A [database connection] handle is usually
• 1992:  ** object. If the database is opened (and/or created) successfully, then
• 1998:  ** sqlite3_open() or sqlite3_open_v2() is called and
• 1999:  ** UTF-16 in the native byte order if sqlite3_open16() is used.
• 2001:  ** Whether or not an error occurs when it is opened, resources
• 2005:  ** The sqlite3_open_v2() interface works like sqlite3_open()
• 2009:  ** [SQLITE_OPEN_NOMUTEX] or [SQLITE_OPEN_FULLMUTEX] flags:
• 2012:  ** <dt>[SQLITE_OPEN_READONLY]</dt>
• 2013:  ** <dd>The database is opened in read-only mode. If the database does not
• 2016:  ** <dt>[SQLITE_OPEN_READWRITE]</dt>
• 2017:  ** <dd>The database is opened for reading and writing if possible, or reading
• 2021:  ** <dt>[SQLITE_OPEN_READWRITE] | [SQLITE_OPEN_CREATE]</dt>
• 2022:  ** <dd>The database is opened for reading and writing, and is creates it if
• 2024:  ** sqlite3_open() and sqlite3_open16().</dd>
• 2027:  ** If the 3rd parameter to sqlite3_open_v2() is not one of the
• 2029:  ** with the [SQLITE_OPEN_NOMUTEX] or [SQLITE_OPEN_FULLMUTEX] flags,
• 2032:  ** If the [SQLITE_OPEN_NOMUTEX] flag is set, then the database connection
• 2033:  ** opens in the multi-thread [threading mode] as long as the single-thread
• 2035:  ** [SQLITE_OPEN_FULLMUTEX] flag is set then the database connection opens
• 2051:  ** The fourth parameter to sqlite3_open_v2() is the name of the
• 2057:  ** of sqlite3_open() and sqlite3_open_v2() must be UTF-8, not whatever
• 2060:  ** sqlite3_open() or sqlite3_open_v2().
• 2066:  int sqlite3_open(
• 2070:  int sqlite3_open16(
• 2074:  int sqlite3_open_v2(
• 2252:  ** prior successful call to [sqlite3_open()], [sqlite3_open_v2()] or
• 2253:  ** [sqlite3_open16()]. The database connection must not have been closed.
• 2470:  ** [sqlite3_blob_open | incremental BLOB I/O] routines.
• 3609:  ** called right after sqlite3_open().
• 3620:  ** Change the key on an open database. If the current database is not
• 3728:  ** [sqlite3_next_stmt(D,S)] must refer to an open database
• 3836:  ** calls to [sqlite3_open()], [sqlite3_open_v2()], and [sqlite3_open16()].
• 3838:  ** that was in effect at the time they were opened.
• 4016:  ** So as not to open security holes in older applications that are
• 4045:  ** is opened using [sqlite3_open()], [sqlite3_open16()],
• 4046:  ** or [sqlite3_open_v2()].
• 4119:   int (*xOpen)(sqlite3_vtab *pVTab, sqlite3_vtab_cursor **ppCursor);
• 4301:  ** [sqlite3_module.xOpen | xOpen] method of the module and are destroyed
• 4358:  ** CAPI3REF: A Handle To An Open BLOB {H17800} <S30230>
• 4361:  ** An instance of this object represents an open BLOB on which
• 4362:  ** [sqlite3_blob_open | incremental BLOB I/O] can be performed.
• 4363:  ** Objects of this type are created by [sqlite3_blob_open()]
• 4372:  ** CAPI3REF: Open A BLOB For Incremental I/O {H17810} <S30230>
• 4374:  ** This interfaces opens a [BLOB handle | handle] to the BLOB located
• 4382:  ** If the flags parameter is non-zero, the the BLOB is opened for read
• 4383:  ** and write access. If it is zero, the BLOB is opened for read access.
• 4401:  ** other than the one the BLOB handle is open on.
• 4411:  int sqlite3_blob_open(
• 4424:  ** Closes an open [BLOB handle].
• 4446:  ** CAPI3REF: Return The Size Of An Open BLOB {H17840} <S30230>
• 4448:  ** Returns the size in bytes of the BLOB accessible via the open
• 4459:  ** This function is used to read data from an open [BLOB handle] into a
• 4461:  ** from the open BLOB, starting at offset iOffset.
• 4481:  ** This function is used to write data into an open [BLOB handle] from a
• 4483:  ** into the open BLOB, starting at offset iOffset.
• 4485:  ** If the [BLOB handle] passed as the first argument was not opened for
• 4486:  ** writing (the flags parameter to [sqlite3_blob_open()] was zero),
• 4776:  #define SQLITE_MUTEX_STATIC_OPEN 4 /* sqlite3BtreeOpen() */
• 4799:  ** <a href="lang_attach.html">ATTACH</a> SQL command that opened the
• 4807:  ** open database file, then SQLITE_ERROR is returned. {H11307} This error
• 5283:  ** As well as the case where the destination database file was opened for

• 105:  **| can be declared by an app when trying to open or create a database file.
• 107:  **| particular db without having first opened the db.) The goal is to inform
• 119:  struct mdbScopeStringSet { // vector of scopes for use in db opening policy
• 126:  #ifndef mdbOpenPolicy_typedef
• 127:  typedef struct mdbOpenPolicy mdbOpenPolicy;
• 128:  #define mdbOpenPolicy_typedef 1
• 131:  #ifndef mdbOpenPolicy_struct
• 132:  #define mdbOpenPolicy_struct 1
• 133:  struct mdbOpenPolicy { // policies affecting db usage for ports and stores
• 134:   mdbScopeStringSet mOpenPolicy_ScopePlan; // predeclare scope usage plan
• 135:   mdb_bool mOpenPolicy_MaxLazy; // nonzero: do least work
• 136:   mdb_bool mOpenPolicy_MinMemory; // nonzero: use least memory
• 138:  #endif /*mdbOpenPolicy_struct*/
• 160:  /*| mdbUsagePolicy: another version of mdbOpenPolicy which uses tokens instead
• 162:  **| db that is already open, while an open policy must be constructed before a
• 163:  **| db has yet been opened.
• 402:   NS_IMETHOD IsOpenMdbObject(nsIMdbEnv* ev, mdb_bool* outOpen) = 0;
• 554:  **| might decide to make on nsIMdbEnv instance for every nsIMdbPort opened, so that
• 652:  **| a port can be opened by this factory. Presumably an app maintains chains
• 653:  **| of factories for different suites, and asks each in turn about opening a
• 659:  **| are few in number. Presumably the set of files that can be opened as
• 660:  **| stores is a subset of the set of files that can be opened as ports. A
• 680:   NS_IMETHOD OpenOldFile(nsIMdbEnv* ev, nsIMdbHeap* ioHeap,
• 685:   // returned should be open and ready for use, and presumably positioned
• 687:   // files must be opened is considered a subclass specific detail, and
• 697:   // files must be opened is considered a subclass specific detail, and
• 720:   NS_IMETHOD CanOpenFilePort(
• 725:   mdb_bool* outCanOpen, // whether OpenFilePort() might succeed
• 728:   NS_IMETHOD OpenFilePort(
• 731:   // const char* inFilePath, // the file to open for readonly import
• 733:   const mdbOpenPolicy* inOpenPolicy, // runtime policies for using db
• 734:   nsIMdbThumb** acqThumb) = 0; // acquire thumb for incremental port open
• 736:   // then call nsIMdbFactory::ThumbToOpenPort() to get the port instance.
• 738:   NS_IMETHOD ThumbToOpenPort( // redeeming a completed thumb from OpenFilePort()
• 740:   nsIMdbThumb* ioThumb, // thumb from OpenFilePort() with done status
• 745:   NS_IMETHOD CanOpenFileStore(
• 750:   mdb_bool* outCanOpenAsStore, // whether OpenFileStore() might succeed
• 751:   mdb_bool* outCanOpenAsPort, // whether OpenFilePort() might succeed
• 754:   NS_IMETHOD OpenFileStore( // open an existing database
• 757:   // const char* inFilePath, // the file to open for general db usage
• 759:   const mdbOpenPolicy* inOpenPolicy, // runtime policies for using db
• 760:   nsIMdbThumb** acqThumb) = 0; // acquire thumb for incremental store open
• 762:   // then call nsIMdbFactory::ThumbToOpenStore() to get the store instance.
• 765:   ThumbToOpenStore( // redeem completed thumb from OpenFileStore()
• 767:   nsIMdbThumb* ioThumb, // thumb from OpenFileStore() with done status
• 775:   const mdbOpenPolicy* inOpenPolicy, // runtime policies for using db
• 793:  **| become closed so the DB can reopen the file in some other manner.
• 815:  **| to support the closing and reopening of the file when the DB needs more
• 819:  **| system, because the file ioThief intends to reopen the file in order
• 822:  **| from Path() in order to know which file to reopen. If Steal() is
• 919:  **|| filepath: the file path used to open the port from the nsIMdbFactory can be
• 962:  **| an open db, so panic purges only make sense when a db is urgently needed.)
• 1308:  **| state of a store in the user interface by quietly closing and reopening a
• 2482:  **| row open that should be closed. Otherwise we'd have ref graph cycles.)

• 228:   mLockFileDesc = open(PromiseFlatCString(lockFilePath).get(),
• 268:   NS_ERROR("Failed to open lock file.");
• 500:   rv = lockFile->OpenNSPRFileDesc(PR_RDONLY, 0, &fd);
• 526:   rv = NS_OK; // Don't propagate error from OpenNSPRFileDesc.
• 583:   // if it's already open.
• 591:   OPEN_ALWAYS,
• 610:   rc = DosOpen(filePath.get(),
• 615:   OPEN_ACTION_CREATE_IF_NEW | OPEN_ACTION_OPEN_IF_EXISTS,
• 616:   OPEN_ACCESS_READWRITE | OPEN_SHARE_DENYREADWRITE | OPEN_FLAGS_NOINHERIT,
• 629:   mLockFileDesc = open_noshr(filePath.get(), O_CREAT, 0666);
• 638:   NS_ERROR("Failed to open lock file.");

• 52:   * he/she wants to stop all network activity, close all open
• 59:   * the application level observer will close all open windows.
• 90:   * in this phase, an application level observer will open a new window.

• 64:   * file containing the content, opens the file and then calls

• 52:  typedef BOOL (WINAPI*OPENPROCESSTOKEN)(HANDLE ProcessHandle,DWORD DesiredAccess,PHANDLE TokenHandle);
• 53:  typedef BOOL (WINAPI*OPENTHREADTOKEN)(HANDLE ThreadHandle,DWORD DesiredAccess,BOOL OpenAsSelf,PHANDLE TokenHandle);
• 68:  OPENPROCESSTOKEN _OpenProcessToken=0;
• 69:  OPENTHREADTOKEN _OpenThreadToken=0;

• 321:   {g.hModAdvAPI,(void**)&_OpenProcessToken, "OpenProcessToken"},
• 322:   {g.hModAdvAPI,(void**)&_OpenThreadToken, "OpenThreadToken"},
• 577:   if (!_OpenProcessToken(GetCurrentProcess(),TOKEN_QUERY,&hToken))goto dieLastErr;
• 592:   if (GetSysVer()>=6 && NO_ERROR==RegOpenKeyEx(HKEY_LOCAL_MACHINE,_T("Software\\Microsoft\\Windows\\CurrentVersion\\Policies\\System"),0,KEY_READ,&hKey))
• 646:   ASSERT(_OpenThreadToken && _OpenProcessToken && _AllocateAndInitializeSid && _EqualSid && _FreeSid);
• 648:   if (_OpenThreadToken(GetCurrentThread(),TOKEN_QUERY,FALSE,&hToken) || _OpenProcessToken(GetCurrentProcess(),TOKEN_QUERY,&hToken))
• 1347:   ASSERT(!_OpenProcessToken && !_EqualSid);

• 91:  #define _tfopen _wfopen
• 92:  #define _topen _wopen
• 185:  #define _tfopen fopen
• 186:  #define _topen _open

• 13:  #include "../../UI/Common/OpenArchive.h"
• 51:  static const LPCWSTR kCantOpenArchive = L"File is not correct archive";
• 56:   COpenCallbackGUI *openCallback,
• 71:   HRESULT result = MyOpenArchive(fileName, extracter.ArchiveLink, openCallback);
• 75:   errorMessage = kCantOpenArchive;

• 43:   if (!inFile.Open(fileName))
• 224:   COpenCallbackGUI openCallback;
• 229:   HRESULT result = ExtractArchive(fullPath, tempDirPath, &openCallback, showProgress,
• 281:   MyMessageBox(L"Can not open file");

• 7:  #include "../../UI/GUI/OpenCallbackGUI.h"
• 12:   COpenCallbackGUI *openCallback,

• 24:  static LPCWSTR kCantOpenFile = L"Can not open output file";
• 185:   _message = kCantOpenFile;

• 276:   HRESULT Open(IInStream *stream, const UInt64 *searchHeaderSizeLimit); // S_FALSE means is not archive

• 101:   STDMETHOD(Open)(IInStream *stream,
• 103:   IArchiveOpenCallback *openArchiveCallback);

• 38:   bool _fileIsOpen;
• 41:   HRESULT OpenFile();

• 33:   _fileIsOpen = false;
• 37:  HRESULT CFolderOutStream::OpenFile()
• 70:   RINOK(OpenFile());
• 84:   if (_fileIsOpen)
• 112:   _fileIsOpen = false;
• 124:   RINOK(OpenFile());
• 125:   _fileIsOpen = true;
• 138:   if (_fileIsOpen)
• 142:   _fileIsOpen = false;
• 147:   RINOK(OpenFile());
• 148:   _fileIsOpen = true;

• 489:  STDMETHODIMP CHandler::Open(IInStream *stream,
• 491:   IArchiveOpenCallback *openArchiveCallback)
• 500:   CMyComPtr<IArchiveOpenCallback> openArchiveCallbackTemp = openArchiveCallback;
• 504:   CMyComPtr<IArchiveOpenVolumeCallback> openVolumeCallback;
• 509:   if (openArchiveCallback)
• 511:   openArchiveCallbackTemp.QueryInterface(
• 516:   if (openArchiveCallback)
• 518:   openArchiveCallbackTemp.QueryInterface(IID_IArchiveOpenVolumeCallback, &openVolumeCallback);
• 525:   if (!openVolumeCallback)
• 532:   RINOK(openVolumeCallback->GetProperty(kpidName, &propVariant));
• 541:   HRESULT result = openVolumeCallback->GetStream(fullName, &inStream);
• 553:   RINOK(archive.Open(inStream, maxCheckStartPosition));
• 624:   RINOK(archive.Open(stream, maxCheckStartPosition));

• 293:  HRESULT CInArchive::Open(IInStream *stream, const UInt64 *searchHeaderSizeLimit)

• 78:  ARCHIVE_INTERFACE(IArchiveOpenCallback, 0x10)
• 95:  ARCHIVE_INTERFACE(IArchiveOpenVolumeCallback, 0x30)
• 108:  ARCHIVE_INTERFACE(IArchiveOpenSetSubArchiveName, 0x50)
• 116:   STDMETHOD(Open)(IInStream *stream, const UInt64 *maxCheckStartPosition,
• 117:   IArchiveOpenCallback *openArchiveCallback) PURE;

• 23:  bool CInFileStream::Open(LPCTSTR fileName)
• 25:   return File.Open(fileName);
• 30:  bool CInFileStream::Open(LPCWSTR fileName)
• 32:   return File.Open(fileName);

• 51:   // _outFile.SetOpenCreationDispositionCreateAlways();
• 86:   return _inFile.Open(_tmpFileName);

• 29:   bool Open(LPCTSTR fileName);
• 32:   bool Open(LPCWSTR fileName);
• 52:   // void Open() { File = GetStdHandle(STD_INPUT_HANDLE); };

• 1:  // OpenCallbackGUI.h
• 3:  #ifndef __OPEN_CALLBACK_GUI_H
• 4:  #define __OPEN_CALLBACK_GUI_H
• 6:  #include "../Common/ArchiveOpenCallback.h"
• 8:  class COpenCallbackGUI: public IOpenCallbackUI
• 23:   COpenCallbackGUI():

• 1:  // OpenCallbackGUI.cpp
• 5:  #include "OpenCallbackGUI.h"
• 15:  HRESULT COpenCallbackGUI::CheckBreak()
• 20:  HRESULT COpenCallbackGUI::SetTotal(const UInt64 *files, const UInt64 *bytes)
• 25:  HRESULT COpenCallbackGUI::SetCompleted(const UInt64 *files, const UInt64 *bytes)
• 31:  HRESULT COpenCallbackGUI::CryptoGetTextPassword(BSTR *password)
• 46:  HRESULT COpenCallbackGUI::GetPasswordIfAny(UString &password)

• 1:  // ArchiveOpenCallback.cpp
• 5:  #include "ArchiveOpenCallback.h"
• 14:  STDMETHODIMP COpenCallbackImp::SetTotal(const UInt64 *files, const UInt64 *bytes)
• 19:  STDMETHODIMP COpenCallbackImp::SetCompleted(const UInt64 *files, const UInt64 *bytes)
• 24:  STDMETHODIMP COpenCallbackImp::GetProperty(PROPID propID, PROPVARIANT *value)
• 66:  int COpenCallbackImp::FindName(const UString &name)
• 77:   COpenCallbackImp *OpenCallbackImp;
• 78:   CMyComPtr<IArchiveOpenCallback> OpenCallbackRef;
• 81:   int index = OpenCallbackImp->FindName(Name);
• 83:   OpenCallbackImp->FileNames.Delete(index);
• 87:  STDMETHODIMP COpenCallbackImp::GetStream(const wchar_t *name,
• 101:   if (!inFile->Open(fullPath))
• 105:   inFile->OpenCallbackImp = this;
• 106:   inFile->OpenCallbackRef = this;
• 112:  STDMETHODIMP COpenCallbackImp::CryptoGetTextPassword(BSTR *password)

• 1:  // OpenArchive.cpp
• 5:  #include "OpenArchive.h"
• 122:  HRESULT ReOpenArchive(IInArchive *archive, const UString &fileName)
• 126:   inStreamSpec->Open(fileName);
• 127:   return archive->Open(inStream, &kMaxCheckStartPosition, NULL);
• 140:  HRESULT OpenArchive(
• 149:   IArchiveOpenCallback *openArchiveCallback)
• 266:   HRESULT result = archive->Open(inStream, &kMaxCheckStartPosition, openArchiveCallback);
• 295:  HRESULT OpenArchive(const UString &filePath,
• 302:   IArchiveOpenCallback *openArchiveCallback)
• 306:   if (!inStreamSpec->Open(filePath))
• 308:   return OpenArchive(inStream, ExtractFileNameFromPath(filePath),
• 313:   defaultItemName, openArchiveCallback);
• 330:  HRESULT OpenArchive(const UString &fileName,
• 341:   IArchiveOpenCallback *openArchiveCallback)
• 343:   HRESULT result = OpenArchive(fileName,
• 347:   archive0, archiverInfo0, defaultItemName0, openArchiveCallback);
• 385:   CMyComPtr<IArchiveOpenSetSubArchiveName> setSubArchiveName;
• 386:   openArchiveCallback->QueryInterface(IID_IArchiveOpenSetSubArchiveName, (void **)&setSubArchiveName);
• 390:   result = OpenArchive(subStream, subPath,
• 394:   archive1, archiverInfo1, defaultItemName1, openArchiveCallback);
• 398:  HRESULT MyOpenArchive(const UString &archiveName,
• 404:   IOpenCallbackUI *openCallbackUI)
• 406:   COpenCallbackImp *openCallbackSpec = new COpenCallbackImp;
• 407:   CMyComPtr<IArchiveOpenCallback> openCallback = openCallbackSpec;
• 408:   openCallbackSpec->Callback = openCallbackUI;
• 413:   openCallbackSpec->Init(
• 418:   return OpenArchive(archiveName,
• 425:   openCallback);
• 428:  HRESULT MyOpenArchive(const UString &archiveName,
• 438:   IOpenCallbackUI *openCallbackUI)
• 440:   COpenCallbackImp *openCallbackSpec = new COpenCallbackImp;
• 441:   CMyComPtr<IArchiveOpenCallback> openCallback = openCallbackSpec;
• 442:   openCallbackSpec->Callback = openCallbackUI;
• 449:   openCallbackSpec->Init(prefix, name);
• 452:   HRESULT result = OpenArchive(archiveName,
• 463:   openCallback);
• 466:   for (int i = 0; i < openCallbackSpec->FileNames.Size(); i++)
• 467:   volumePaths.Add(prefix + openCallbackSpec->FileNames[i]);
• 492:  HRESULT OpenArchive(const UString &archiveName,
• 494:   IArchiveOpenCallback *openCallback)
• 496:   return OpenArchive(archiveName,
• 503:   openCallback);
• 506:  HRESULT MyOpenArchive(const UString &archiveName,
• 508:   IOpenCallbackUI *openCallbackUI)
• 510:   return MyOpenArchive(archiveName,
• 517:   openCallbackUI);
• 520:  HRESULT ReOpenArchive(CArchiveLink &archiveLink,
• 526:   return MyOpenArchive(fileName, archiveLink, 0);
• 527:   return ReOpenArchive(archiveLink.GetArchive(), fileName);

• 72:   if(key.Open(baseKey, kRegistryPath, KEY_READ) == ERROR_SUCCESS)

• 1:  // ArchiveOpenCallback.h
• 3:  #ifndef __ARCHIVE_OPEN_CALLBACK_H
• 4:  #define __ARCHIVE_OPEN_CALLBACK_H
• 15:  struct IOpenCallbackUI
• 26:  class COpenCallbackImp:
• 27:   public IArchiveOpenCallback,
• 28:   public IArchiveOpenVolumeCallback,
• 29:   public IArchiveOpenSetSubArchiveName,
• 38:   IArchiveOpenVolumeCallback,
• 40:   IArchiveOpenSetSubArchiveName
• 44:   IArchiveOpenVolumeCallback,
• 45:   IArchiveOpenSetSubArchiveName
• 52:   // IArchiveOpenVolumeCallback
• 75:   IOpenCallbackUI *Callback;

• 1:  // OpenArchive.h
• 3:  #ifndef __OPENARCHIVE_H
• 4:  #define __OPENARCHIVE_H
• 11:  #include "ArchiveOpenCallback.h"
• 29:  HRESULT OpenArchive(
• 38:   IArchiveOpenCallback *openArchiveCallback);
• 40:  HRESULT OpenArchive(const UString &filePath,
• 47:   IArchiveOpenCallback *openArchiveCallback);
• 49:  HRESULT OpenArchive(const UString &filePath,
• 60:   IArchiveOpenCallback *openArchiveCallback);
• 63:  HRESULT ReOpenArchive(IInArchive *archive,
• 66:  HRESULT MyOpenArchive(const UString &archiveName,
• 72:   IOpenCallbackUI *openCallbackUI);
• 74:  HRESULT MyOpenArchive(const UString &archiveName,
• 84:   IOpenCallbackUI *openCallbackUI);
• 122:  HRESULT OpenArchive(const UString &archiveName,
• 124:   IArchiveOpenCallback *openCallback);
• 126:  HRESULT MyOpenArchive(const UString &archiveName,
• 128:   IOpenCallbackUI *openCallbackUI);
• 130:  HRESULT ReOpenArchive(CArchiveLink &archiveLink,

• 12:   bool _streamIsOpen;
• 15:   CStdOutStream (): _streamIsOpen(false) {};
• 16:   CStdOutStream (FILE *stream): _streamIsOpen(false), _stream(stream) {};
• 18:   bool Open(const char *fileName);

• 13:   bool _streamIsOpen;
• 16:   CStdInStream(): _streamIsOpen(false) {};
• 17:   CStdInStream(FILE *stream): _streamIsOpen(false), _stream(stream) {};
• 19:   bool Open(LPCTSTR fileName);

• 13:  static const char *kFileOpenMode = "wt";
• 18:  bool CStdOutStream::Open(const char *fileName)
• 21:   _stream = fopen(fileName, kFileOpenMode);
• 22:   _streamIsOpen = (_stream != 0);
• 23:   return _streamIsOpen;
• 28:   if(!_streamIsOpen)
• 30:   _streamIsOpen = (fclose(_stream) != 0);
• 31:   return !_streamIsOpen;
• 36:   if(!_streamIsOpen)

• 15:  static LPCTSTR kFileOpenMode = TEXT("r");
• 19:  bool CStdInStream::Open(LPCTSTR fileName)
• 22:   _stream = _tfopen(fileName, kFileOpenMode);
• 23:   _streamIsOpen = (_stream != 0);
• 24:   return _streamIsOpen;
• 29:   if(!_streamIsOpen)
• 31:   _streamIsOpen = (fclose(_stream) != 0);
• 32:   return !_streamIsOpen;

• 28:   return (_fileIsOpen = (_handle != INVALID_HANDLE_VALUE));
• 41:   return (_fileIsOpen = (_handle != INVALID_HANDLE_VALUE));
• 50:   if(!_fileIsOpen)
• 53:   _fileIsOpen = !result;
• 120:  bool CInFile::Open(LPCTSTR fileName, DWORD shareMode, DWORD creationDisposition, DWORD flagsAndAttributes)
• 123:  bool CInFile::Open(LPCTSTR fileName)
• 124:   { return Open(fileName, FILE_SHARE_READ, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL); }
• 127:  bool CInFile::Open(LPCWSTR fileName, DWORD shareMode, DWORD creationDisposition, DWORD flagsAndAttributes)
• 130:  bool CInFile::Open(LPCWSTR fileName)
• 131:   { return Open(fileName, FILE_SHARE_READ, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL); }
• 173:  bool COutFile::Open(LPCTSTR fileName, DWORD shareMode, DWORD creationDisposition, DWORD flagsAndAttributes)
• 179:  bool COutFile::Open(LPCTSTR fileName, DWORD creationDisposition)
• 180:   { return Open(fileName, FILE_SHARE_READ, creationDisposition, FILE_ATTRIBUTE_NORMAL); }
• 183:   { return Open(fileName, GetCreationDisposition(createAlways)); }
• 187:  bool COutFile::Open(LPCWSTR fileName, DWORD shareMode, DWORD creationDisposition, DWORD flagsAndAttributes)
• 190:  bool COutFile::Open(LPCWSTR fileName, DWORD creationDisposition)
• 191:   { return Open(fileName, FILE_SHARE_READ, creationDisposition, FILE_ATTRIBUTE_NORMAL); }
• 194:   { return Open(fileName, GetCreationDisposition(createAlways)); }

• 13:   bool IsOpen() const { return _handle != 0; }
• 43:   if (!IsOpen())

• 30:   bool Open(DWORD desiredAccess, bool inheritHandle, LPCTSTR name)
• 32:   _handle = ::OpenEvent(desiredAccess, BoolToBOOL(inheritHandle), name);
• 74:   bool Open(DWORD desiredAccess, bool inheritHandle, LPCTSTR name)
• 76:   _handle = ::OpenMutex(desiredAccess, BoolToBOOL(inheritHandle), name);

• 27:   bool _fileIsOpen;
• 37:   CFileBase(): _fileIsOpen(false){};
• 56:   bool Open(LPCTSTR fileName, DWORD shareMode, DWORD creationDisposition, DWORD flagsAndAttributes);
• 57:   bool Open(LPCTSTR fileName);
• 59:   bool Open(LPCWSTR fileName, DWORD shareMode, DWORD creationDisposition, DWORD flagsAndAttributes);
• 60:   bool Open(LPCWSTR fileName);
• 71:   bool Open(LPCTSTR fileName, DWORD shareMode, DWORD creationDisposition, DWORD flagsAndAttributes);
• 72:   bool Open(LPCTSTR fileName, DWORD creationDisposition);
• 76:   bool Open(LPCWSTR fileName, DWORD shareMode, DWORD creationDisposition, DWORD flagsAndAttributes);
• 77:   bool Open(LPCWSTR fileName, DWORD creationDisposition);
• 82:   void SetOpenCreationDisposition(DWORD creationDisposition)
• 84:   void SetOpenCreationDispositionCreateAlways()

• 534:   rv = destChannel->AsyncOpen(this, nsnull);
• 1244:   // Open a channel to the URI
• 1351:   nsresult rv = aChannel->AsyncOpen(this, nsnull);
• 1360:   // Opening failed, but do we care?
• 1533:   // 2. For each URI create an OutputData entry and open a channel to save
• 2375:   // Enumerate through existing open channels looking for one with

• 181:   * Save a channel to a file. It must not be opened yet.

• 143:   block->SetString(eOpeningSound, NS_SYSSOUND_ALERT_DIALOG.get());
• 188:   block->SetString(eOpeningSound, NS_SYSSOUND_ALERT_DIALOG.get());
• 234:   block->SetString(eOpeningSound, NS_SYSSOUND_CONFIRM_DIALOG.get());
• 284:   block->SetString(eOpeningSound, NS_SYSSOUND_CONFIRM_DIALOG.get());
• 386:   block->SetString(eOpeningSound, NS_SYSSOUND_CONFIRM_DIALOG.get());
• 462:   block->SetString(eOpeningSound, NS_SYSSOUND_PROMPT_DIALOG.get());
• 538:   block->SetString(eOpeningSound, NS_SYSSOUND_PROMPT_DIALOG.get());
• 618:   block->SetString(eOpeningSound, NS_SYSSOUND_PROMPT_DIALOG.get());
• 753:   paramBlock->SetString(eOpeningSound, NS_SYSSOUND_ALERT_DIALOG.get());
• 756:   mWatcher->OpenWindow(aParent, "chrome://global/content/commonDialog.xul",
• 784:   rv = mWatcher->OpenWindow(aParent, aChromeURL, "_blank",

• 106:   // Just like OpenWindowJS, but knows whether it got called via OpenWindowJS
• 107:   // (which means called from script) or called via OpenWindow.
• 108:   nsresult OpenWindowJSInternal(nsIDOMWindow *aParent,
• 135:   static nsresult ReadyOpenedDocShellItem(nsIDocShellTreeItem *aOpenedItem,
• 138:   nsIDOMWindow **aOpenedWindow);
• 139:   static void SizeOpenedDocShellItem(nsIDocShellTreeItem *aDocShellItem,

• 54:   mDefaultEnabled(DispatchCustomEvent("DOMWillOpenModalDialog"))

• 365:  nsWindowWatcher::OpenWindow(nsIDOMWindow *aParent,
• 422:   return OpenWindowJSInternal(aParent, aUrl, aName, aFeatures, dialog,
• 468:  nsWindowWatcher::OpenWindowJS(nsIDOMWindow *aParent,
• 487:   return OpenWindowJSInternal(aParent, aUrl, aName, aFeatures, aDialog,
• 492:  nsWindowWatcher::OpenWindowJSInternal(nsIDOMWindow *aParent,
• 564:   // our internal modal option, treat the window we're opening as a
• 585:   // open() is called from chrome on a non-chrome window, push
• 588:   // that runs while opening the new window.
• 594:   // We're going to either open up a new window ourselves or ask a
• 600:   // do it if we're opening a dialog or if our parent is a chrome window or
• 601:   // if we're opening something that has modal, dialog, or chrome flags set.
• 605:   nsIWebBrowserChrome::CHROME_OPENAS_DIALOG |
• 606:   nsIWebBrowserChrome::CHROME_OPENAS_CHROME))) {
• 622:   // manipulates the window it just opened and then the load
• 653:   // where we can't shut down because an invisible window is open. If
• 669:   "attempted to open a new window with no WindowCreator");
• 675:   some hints. The only hint at this time is whether the opening window
• 678:   we clear that indicator if the opener is chrome, so that the
• 691:   // chrome is always allowed, so clear the flag if the opener is chrome
• 734:   rv = ReadyOpenedDocShellItem(newDocShellItem, aParent, windowIsNew, _retval);
• 741:   in the open call as disabling persistence of those attributes.
• 822:   // Notify observers that the window is open and ready.
• 831:   // Now we have to set the right opener principal on the new window. Note
• 834:   // set said opener principal, we need to do it for all URIs, including
• 844:   // Now set the opener principal on the new window. Note that we need to do
• 845:   // this no matter whether we were opened from JS; if there is nothing on
• 874:   newWindow->SetOpenerScriptPrincipal(newWindowPrincipal);
• 954:   SizeOpenedDocShellItem(newDocShellItem, aParent, sizeSpec);
• 969:   // we're opening a modal content window (the helper classes are
• 980:   // Default to cancel not opening the modal window.
• 986:   // Reset popup state while opening a modal dialog, and firing
• 988:   // being active the whole time a modal dialog is open.
• 989:   nsAutoPopupStatePusher popupStatePusher(modalContentWindow, openAbused);
• 1008:   rv = os->AddObserver(aObserver, "domwindowopened", PR_FALSE);
• 1026:   os->RemoveObserver(aObserver, "domwindowopened");
• 1171:   // a window being added to us signifies a newly opened window.
• 1176:   rv = os->NotifyObservers(domwin, "domwindowopened", 0);
• 1386:   This just prints a warning message an continues; we open the window anyway,
• 1438:   nsIWebBrowserChrome::CHROME_OPENAS_DIALOG |
• 1439:   nsIWebBrowserChrome::CHROME_OPENAS_CHROME;
• 1450:   in the standards-compliant window.(normal)open. */
• 1473:   rv = prefs->GetBranch("dom.disable_window_open_feature.", getter_AddRefs(prefBranch));
• 1531:   nsIWebBrowserChrome::CHROME_OPENAS_CHROME : 0;
• 1541:   nsIWebBrowserChrome::CHROME_OPENAS_DIALOG : 0;
• 1544:   and opened as chrome, unless explicitly told otherwise. */
• 1547:   chromeFlags |= nsIWebBrowserChrome::CHROME_OPENAS_DIALOG;
• 1549:   chromeFlags |= nsIWebBrowserChrome::CHROME_OPENAS_CHROME;
• 1572:   prevents untrusted script from opening modal windows in general
• 1576:   nsIWebBrowserChrome::CHROME_OPENAS_CHROME);
• 1579:   if (!(chromeFlags & nsIWebBrowserChrome::CHROME_OPENAS_CHROME)) {
• 1580:   // Remove the dependent flag if we're not opening as chrome
• 1636:   known open window. a failure to find the item will not
• 1764:   been created. Note it also sets the window's opener to the parent,
• 1768:  nsWindowWatcher::ReadyOpenedDocShellItem(nsIDocShellTreeItem *aOpenedItem,
• 1771:   nsIDOMWindow **aOpenedWindow)
• 1775:   *aOpenedWindow = 0;
• 1776:   nsCOMPtr<nsPIDOMWindow> piOpenedWindow(do_GetInterface(aOpenedItem));
• 1777:   if (piOpenedWindow) {
• 1780:   piOpenedWindow->SetOpenerWindow(internalParent, aWindowIsNew); // damnit
• 1788:   do_QueryInterface(aOpenedItem);
• 1797:   do_QueryInterface(piOpenedWindow->GetExtantDocument());
• 1803:   rv = CallQueryInterface(piOpenedWindow, aOpenedWindow);
• 1877:  nsWindowWatcher::SizeOpenedDocShellItem(nsIDocShellTreeItem *aDocShellItem,
• 1992:   // open() on a chrome window

• 44:   * Helper class for dealing with notifications around opening modal

• 53:   eDialogTitle=12, eOpeningSound=13};

• 53:   * a list of open top-level windows, and allows some operations on them.
• 82:   @param aURL url to which to open the new window. Must already be
• 84:   @param aName window name from JS window.open. can be null. If a window
• 85:   with this name already exists, the openWindow call may just load
• 87:   @param aFeatures window features from JS window.open. can be null.
• 103:   nsIDOMWindow openWindow(in nsIDOMWindow aParent, in string aUrl,
• 108:   when a window is opened or closed (added to or removed from this
• 112:   opened or closed. Its Observe method will be
• 116:   aSubject the window being opened or closed, sent as an nsISupports
• 118:   aTopic a wstring, either "domwindowopened" or "domwindowclosed".
• 124:   when a window is opened or closed (added to or removed from this
• 131:   /** Get an iterator for currently open windows in the order they were opened,
• 154:   openWindow will use it to create new windows.
• 162:   Watcher keeps a list of all top-level DOM windows currently open,
• 178:   Note: This method will search all open windows for any window or
• 189:   if no windows are open, but should otherwise always return a valid

• 76:   /** Like the public interface's open(), but can deal with openDialog
• 81:   @param aURL url to which to open the new window. Must already be
• 83:   @param aName window name from JS window.open. can be null. If a window
• 84:   with this name already exists, the openWindow call may just load
• 86:   @param aFeatures window features from JS window.open. can be null.
• 87:   @param aDialog use dialog defaults (see nsIDOMWindowInternal::openDialog)
• 99:   nsIDOMWindow openWindowJS(in nsIDOMWindow aParent, in string aUrl,

• 129:  /* void showProgress (in nsIDOMWindow parent, in nsIWebBrowserPrint webBrowserPrint, in nsIPrintSettings printSettings, in nsIObserver openDialogObserver, in boolean isForPrinting, out nsIWebProgressListener webProgressListener, out nsIPrintProgressParams printProgressParams, out boolean notifyOnOpen); */
• 134:   nsIObserver* openDialogObserver, // ok to be null
• 138:   PRBool* notifyOnOpen)
• 142:   NS_ENSURE_ARG(notifyOnOpen);
• 144:   *notifyOnOpen = PR_FALSE;
• 170:   mPrintProgress->OpenProgressDialog(parentDOMIntl,
• 172:   *printProgressParams, openDialogObserver, notifyOnOpen);
• 278:   rv = mWatcher->OpenWindow(aParent, aChromeURL, "_blank",

• 73:  /* void openProgressDialog (in nsIDOMWindowInternal parent, in string dialogURL, in nsISupports parameters); */
• 74:  NS_IMETHODIMP nsPrintProgress::OpenProgressDialog(nsIDOMWindowInternal *parent,
• 77:   nsIObserver *openDialogObserver,
• 78:   PRBool *notifyOnOpen)
• 80:   *notifyOnOpen = PR_TRUE;
• 81:   m_observer = openDialogObserver;
• 108:   // Open the dialog.
• 110:   rv = parent->OpenDialog(NS_ConvertASCIItoUTF16(dialogURL),

• 72:  /* void openProgressDialog (in nsIDOMWindowInternal parent, in string dialogURL, in nsISupports parameters); */
• 73:  NS_IMETHODIMP nsPrintProgress::OpenProgressDialog(nsIDOMWindowInternal *parent,
• 76:   nsIObserver *openDialogObserver,
• 77:   PRBool *notifyOnOpen)
• 79:   m_observer = openDialogObserver;
• 107:   // Open the dialog.
• 109:   rv = parent->OpenDialog(NS_ConvertASCIItoUTF16(dialogURL),
• 114:   *notifyOnOpen = PR_TRUE;

• 761:   BOOL status = ::OpenPrinterW(printName, &hPrinter, NULL);
• 881:   if(!::OpenPrinterW(const_cast<wchar_t*>(printerName), &hPrinter, NULL)) {

• 196:  /* void showProgress (in nsIDOMWindow parent, in nsIWebBrowserPrint webBrowserPrint, in nsIPrintSettings printSettings, in nsIObserver openDialogObserver, in boolean isForPrinting, out nsIWebProgressListener webProgressListener, out nsIPrintProgressParams printProgressParams, out boolean notifyOnOpen); */
• 201:   nsIObserver* openDialogObserver, // ok to be null
• 205:   PRBool* notifyOnOpen)
• 209:   NS_ENSURE_ARG(notifyOnOpen);
• 211:   *notifyOnOpen = PR_FALSE;
• 243:   mPrintProgress->OpenProgressDialog(parentDOMIntl,
• 245:   *printProgressParams, openDialogObserver, notifyOnOpen);
• 334:   rv = mWatcher->OpenWindow(aParent, aChromeURL, "_blank",

• 101:  /* void openProgressDialog (in nsIDOMWindowInternal parent, in string dialogURL, in nsISupports parameters); */
• 102:  NS_IMETHODIMP nsPrintProgress::OpenProgressDialog(nsIDOMWindowInternal *parent,
• 105:   nsIObserver *openDialogObserver,
• 106:   PRBool *notifyOnOpen)
• 108:   *notifyOnOpen = PR_TRUE;
• 109:   m_observer = openDialogObserver;
• 137:   // Open the dialog.
• 139:   rv = parent->OpenDialog(NS_ConvertASCIItoUTF16(dialogURL),

• 126:  /* void showProgress (in nsIDOMWindow parent, in nsIWebBrowserPrint webBrowserPrint, in nsIPrintSettings printSettings, in nsIObserver openDialogObserver, in boolean isForPrinting, out nsIWebProgressListener webProgressListener, out nsIPrintProgressParams printProgressParams, out boolean notifyOnOpen); */
• 131:   nsIObserver* openDialogObserver, // ok to be null
• 135:   PRBool* notifyOnOpen)
• 139:   NS_ENSURE_ARG(notifyOnOpen);
• 141:   *notifyOnOpen = PR_FALSE;
• 167:   mPrintProgress->OpenProgressDialog(parentDOMIntl,
• 169:   *printProgressParams, openDialogObserver, notifyOnOpen);
• 258:   rv = mWatcher->OpenWindow(aParent, aChromeURL, "_blank",

• 72:  /* void openProgressDialog (in nsIDOMWindowInternal parent, in string dialogURL, in nsISupports parameters); */
• 73:  NS_IMETHODIMP nsPrintProgress::OpenProgressDialog(nsIDOMWindowInternal *parent,
• 76:   nsIObserver *openDialogObserver,
• 77:   PRBool *notifyOnOpen)
• 79:   *notifyOnOpen = PR_TRUE;
• 80:   m_observer = openDialogObserver;
• 107:   // Open the dialog.
• 109:   rv = parent->OpenDialog(NS_ConvertASCIItoUTF16(dialogURL),

• 64:   void OpenURL(String *url);

• 330:  Gecko::OpenURL(String *aUrl)
• 416:   // if opened as chrome, it'll be made visible after the chrome has loaded.
• 418:   if (!(aChromeFlags & nsIWebBrowserChrome::CHROME_OPENAS_CHROME))

• 132:   bool openWindow() { return true; };

• 102:  static nsresult OpenWebPage(const char * url);
• 292:   // Open the initial browser window
• 293:   OpenWebPage(gFirstURL);
• 312:   to a window creation function. This is how all new windows are opened,
• 339:  // FUNCTION: OpenWebPage()
• 341:  // PURPOSE: Opens a new browser dialog and starts it loading to the
• 344:  nsresult OpenWebPage(const char *url)
• 347:   printf("In OpenWebpage\n");
• 398:   OPENFILENAME saveFileNameInfo;
• 654:   OpenWebPage(gFirstURL);
• 925:  // PURPOSE: Dialog handler procedure for the open uri dialog.
• 1119:   // if opened as chrome, it'll be made visible after the chrome has loaded.
• 1121:   if (!(aChromeFlags & nsIWebBrowserChrome::CHROME_OPENAS_CHROME))
• 1183:   OpenWebPage(gFirstURL);

• 385:   (mChromeFlags & nsIWebBrowserChrome::CHROME_OPENAS_CHROME)) {

• 10:  #define MOZ_OpenURI 104
• 44:  #define MOZ_Open 32771

• 100:   nsCOMPtr<nsIWebBrowserChrome> mDependentParent; // opener (for dependent windows only)

• 30:  #define IDC_OPEN_USING 1018

• 85:   void OpenTest(nsIChannel *, PRInt16);
• 86:   void AsyncOpenTest(nsIChannel *, PRInt16);
• 87:   void PostAsyncOpenTests(nsIChannel *, PRInt16);

• 204:   int hCrtOut = _open_osfhandle(
• 210:   FILE *hfOut = _fdopen(hCrtOut, "w");
• 220:   int hCrtErr = _open_osfhandle(
• 226:   FILE *hfErr = _fdopen(hCrtErr, "w");
• 412:   // has opened multiple browser windows shut all
• 507:  // When the profile switch happens, all open browser windows need to be
• 620:   // Close all open windows. Alternatively, we could just call CBrowserWindow::Stop()

• 102:   ON_COMMAND(ID_TESTS_ADDURICONTENTLISTENER_OPENURI, OnTestsAddUriContentListenerByOpenUri)
• 103:   ON_COMMAND(ID_TESTS_NSNEWCHANNEL, OnTestsNSNewChannelAndAsyncOpen)
• 208:   ON_COMMAND(ID_INTERFACES_NSICHANNEL_OPEN, OnInterfacesNsichannel)
• 209:   ON_COMMAND(ID_INTERFACES_NSICHANNEL_ASYNCOPEN, OnInterfacesNsichannel)
• 571:  void CTests::OnTestsAddUriContentListenerByOpenUri()
• 587:   RvTestResult(rv, "For OpenURI(): NS_NewURI() test", 1);
• 591:   RvTestResult(rv, "For OpenURI(): NS_NewChannel() test", 1);
• 598:   rv = myLoader->OpenURI(theChannel, PR_TRUE, qaBrowserImpl);
• 599:   RvTestResult(rv, "nsIUriLoader->OpenURI() test", 2);
• 604:  void CTests::OnTestsNSNewChannelAndAsyncOpen()
• 622:   QAOutput("We didn't get the Channel for AsyncOpen(). Test failed.", 1);
• 626:   QAOutput("AynchOpen() test:", 2);
• 630:   channelTests->AsyncOpenTest(theChannel, 2);;
• 829:   myFile.Open( strFileName, CStdioFile::modeCreate | CStdioFile::modeWrite
• 843:   myFile.Open( strFileName, CStdioFile::modeCreate | CStdioFile::modeWrite
• 912:   rv = myLoader->OpenURI(theChannel, PR_TRUE, qaBrowserImpl);
• 913:   RvTestResult(rv, "nsIUriLoader->OpenURI() test for file url", 2);
• 933:   rv = myLoader->OpenURI(theChannel, PR_TRUE, qaBrowserImpl);
• 934:   RvTestResult(rv, "nsIUriLoader->OpenURI() test for data url", 2);

• 215:   if (::RegOpenKeyEx(HKEY_LOCAL_MACHINE, szKey, 0, KEY_QUERY_VALUE, &hRegKey) == ERROR_SUCCESS)

• 260:   QAOutput("We didn't get the listener for AsyncOpen(). Test failed.", 1);
• 264:   rv = theChannel->AsyncOpen(listener, nsnull);
• 265:   RvTestResult(rv, "AsyncOpen()", 1);
• 266:   RvTestResultDlg(rv, "AsyncOpen()");

• 72:   void OpenURL(const char* pUrl);
• 73:   void OpenURL(const PRUnichar* pUrl);
• 78:   void OpenURLInNewWindow(const PRUnichar* pUrl);
• 134:   BOOL OpenViewSourceWindow(const char* pUrl);
• 165:   afx_msg void OnFileOpen();
• 181:   afx_msg void OnOpenLinkInNewWindow();

• 341:  void CnsIChannelTests::OpenTest(nsIChannel *theChannel, PRInt16 displayMode)
• 345:   QAOutput("Didn't get nsIChannel object. OpenTest failed.", displayMode);
• 348:   rv = theChannel->Open(getter_AddRefs(theInputStream));
• 349:   RvTestResult(rv, "OpenTest", displayMode);
• 351:   QAOutput("Didn't get theInputStream object. OpenTest failed.", displayMode);
• 354:  void CnsIChannelTests::AsyncOpenTest(nsIChannel *theChannel, PRInt16 displayMode)
• 361:   QAOutput("Didn't get nsIChannel object. AsyncOpenTest failed.", displayMode);
• 365:   QAOutput("Didn't get the stream listener object. AsyncOpenTest failed.", displayMode);
• 371:   QAOutput("Didn't get the nsISupports object. AsyncOpen() failed.", displayMode);
• 375:   rv = theChannel->AsyncOpen(listener, theSupports);
• 376:   RvTestResult(rv, "AsyncOpen()", displayMode);
• 378:   RvTestResultDlg(rv, "AsyncOpen()");
• 381:  void CnsIChannelTests::PostAsyncOpenTests(nsIChannel *theChannel, PRInt16 displayMode)
• 383:   // These tests are run after the channel is opened (using AsyncOpen())
• 384:   // To run them in TestEmbed, select Tests > asyncOpen menu and enter complete URL with protocol
• 436:   AsyncOpenTest(theChannel, 1);
• 440:   AsyncOpenTest(theChannel, 1);
• 444:   AsyncOpenTest(theChannel, 1);
• 448:   AsyncOpenTest(theChannel, 1);
• 452:   AsyncOpenTest(theChannel, 1);
• 456:   AsyncOpenTest(theChannel, 1);
• 460:   AsyncOpenTest(theChannel, 1);
• 463:   case ID_INTERFACES_NSICHANNEL_OPEN :
• 464:   OpenTest(theChannel, 2);
• 466:   case ID_INTERFACES_NSICHANNEL_ASYNCOPEN :
• 467:   AsyncOpenTest(theChannel, 2);
• 493:   AsyncOpenTest(theChannel, 1);
• 494:   // PostAsyncOpenTests() called from nsIRequestObserver::OnStartRequest (in BrowserImpl.cpp)

• 96:   ON_COMMAND(ID_FILE_OPEN, OnFileOpen)
• 112:   ON_COMMAND(ID_OPEN_LINK_IN_NEW_WINDOW, OnOpenLinkInNewWindow)
• 349:   OpenViewSourceWindow(strUrl.GetBuffer(0));
• 352:   OpenURL(strUrl.GetBuffer(0));
• 367:   OpenViewSourceWindow(strUrl.GetBuffer(0));
• 369:   OpenURL(strUrl.GetBuffer(0));
• 377:  BOOL CBrowserView::OpenViewSourceWindow(const char* pUrl)
• 390:   pFrm->m_wndBrowserView.OpenURL(pUrl);
• 420:   OpenViewSourceWindow(viewSrcUrl.get());
• 473:   OpenURL(strHomeURL);
• 630:  void CBrowserView::OnFileOpen()
• 641:   OpenURL(strFullPath);
• 707:  void CBrowserView::OpenURL(const char* pUrl)
• 709:   OpenURL(NS_ConvertASCIItoUTF16(pUrl).get());
• 712:  void CBrowserView::OpenURL(const PRUnichar* pUrl)
• 734:  void CBrowserView::OpenURLInNewWindow(const PRUnichar* pUrl)
• 745:   // Note that OpenURL() is overloaded - one takes a "char *"
• 749:   pFrm->m_wndBrowserView.OpenURL(pUrl);
• 762:   if (! OpenClipboard())
• 784:  void CBrowserView::OnOpenLinkInNewWindow()
• 787:   OpenURLInNewWindow(mCtxMenuLinkUrl.get());
• 793:   OpenURLInNewWindow(mCtxMenuImgSrc.get());

• 104:   if(! myFile.Open( strFileName, CStdioFile::modeCreate | CStdioFile::modeWrite
• 107:   CString failCause = "Unable to open file. Reason : ";
• 125:   case CFileException::tooManyOpenFiles:
• 126:   failCause += "The permitted number of open files was exceeded.";

• 235:  // Ex: In response to a JavaScript Window.Open() call
• 277:  // Ex: In response to a JavaScript Window.Open() call of
• 280:  // window.open("http://www.mozilla.org", "theWin", "width=200, height=400");
• 552:   // these are for nsIChannel tests found in nsichanneltests.cpp (post AsyncOpen() tests)
• 559:   QAOutput("\n Start nsIChannel PostAsyncOpenTests tests:");
• 560:   channelTests->PostAsyncOpenTests(channel, 1);
• 563:   QAOutput("No object to run PostAsyncOpenTests() for nsIChannel.", 1);
• 635:  NS_IMETHODIMP CBrowserImpl::OnStartURIOpen(nsIURI *aURI, PRBool *_retval)
• 637:   QAOutput("nsIURIContentListener->OnStartURIOpen()",1);
• 640:   // set return boolean to false so uriOpen doesn't abort

• 116:   afx_msg void OnTestsAddUriContentListenerByOpenUri();
• 117:   afx_msg void OnTestsNSNewChannelAndAsyncOpen();

• 86:   local_file->OpenANSIFileDesc(aMode, &fd);

• 72:  #define ID_OPEN_LINK_IN_NEW_WINDOW 32783
• 272:  #define ID_TESTS_ADDURICONTENTLISTENER_OPENURI 33000
• 295:  #define ID_INTERFACES_NSICHANNEL_OPEN 33026
• 296:  #define ID_INTERFACES_NSICHANNEL_ASYNCOPEN 33027

• 179:   QAOutput("Didn't get nsIChannel object. AsyncOpenTest will not be run.", 1);
• 182:   // this will open the channel and run the httpChannel response tests
• 183:   channelObj->AsyncOpenTest(theChannel, 1);

• 156:   rv = registry->OpenWellKnownRegistry(nsIRegistry::ApplicationRegistry);
• 183:   rv = registry->OpenWellKnownRegistry(nsIRegistry::ApplicationRegistry);

• 303:   // This is mainly needed when the window size is specified in the window.open()

• 40:   * open a new window. This interface can be implemented by Gecko consumers who
• 43:   * toplevel window open.
• 55:   * behavior of opening a new window can be easly modified. When the window
• 56:   * watcher needs to open a new window, it will first check with the
• 59:   * to actually open a new window.
• 91:   * @param aName The name of the window being opened. Setting the name on the
• 95:   * @param aFeatures The feature string for the window being opened. This may
• 103:   * windows were opened by the user as opposed to
• 104:   * being opened programmatically. This should be set
• 110:   * create a new window. The returned window may be newly opened by

• 77:   to open or whether to cancel window creation. It will not

• 95:  EmbedStream::OpenStream(const char *aBaseURI, const char *aContentType)

• 92:   if (aChromeFlags & nsIWebBrowserChrome::CHROME_OPENAS_CHROME)

• 587:   char *statusMessage = "Opening connection:";

• 73:  EmbedContentListener::OnStartURIOpen(nsIURI *aURI,
• 74:   PRBool *aAbortOpen)
• 82:   if (!moz->open_cb)
• 87:   cbinfo.reason = Pt_CB_MOZ_OPEN;
• 88:   cb = moz->open_cb;
• 95:   *aAbortOpen = PR_TRUE;
• 99:   *aAbortOpen = PR_FALSE;

• 106:   nsresult OpenStream (const char *aBaseURI, const char *aContentType);

• 411:  // moz->MyBrowser->WebBrowserContainer->OpenStream( moz->MyBrowser->WebBrowser, "file://", "text/html" );
• 1103:   { Pt_CB_MOZ_OPEN, NULL, NULL, Pt_ARG_IS_CALLBACK_LIST(PtMozillaWidget_t, open_cb) },

• 649:  EmbedPrivate::OpenStream(const char *aBaseURI, const char *aContentType)
• 662:   rv = mStream->OpenStream(aBaseURI, aContentType);
• 713:   // creating a new window ) so it's OK to walk the list of open

• 92:  #define Pt_CB_MOZ_OPEN Pt_RESOURCE( 104, 26 )
• 130:  // url change callback, also used for open callback
• 131:  // the open callback returns Pt_END to cancel the open of that site
• 224:   Pt_MOZ_FLAG_OPENASDIALOG = 1073741824U,
• 225:   Pt_MOZ_FLAG_OPENASCHROME = 2147483648U
• 374:   PtCallbackList_t *open_cb;

• 382:   rv = mWatcher->OpenWindow(aParent, aChromeURL, "_blank",

• 58:   NS_METHOD OpenStream (const char *aBaseURI, const char *aContentType);

• 466:  int moz_open_cb(PtWidget_t *widget, void *data, PtCallbackInfo_t *cbinfo)
• 772:   PtAddCallback(info->web, Pt_CB_MOZ_OPEN, moz_open_cb, NULL);

• 1823:  /* void openStream(in nsIURI aBaseURI, in ACString aContentType); */
• 1824:  NS_IMETHODIMP nsWebBrowser::OpenStream(nsIURI *aBaseURI, const nsACString& aContentType)
• 1837:   return mStream->OpenStream(aBaseURI, aContentType);

• 1524:  // This fires after a tooltip has been open for a certain length of time. Just tell

• 106:   // meaningful if CHROME_OPENAS_CHROME is set; content windows should not be
• 113:   const unsigned long CHROME_OPENAS_DIALOG = 0x40000000;
• 114:   const unsigned long CHROME_OPENAS_CHROME = 0x80000000;

• 154:   * @param openDialogObserver - an observer that will be notifed when the dialog is opened
• 158:   * @param notifyOnOpen - this indicates that the observer will be notified when the progress
• 159:   * dialog has been opened. If false is returned it means the observer
• 166:   in nsIObserver openDialogObserver,
• 170:   out boolean notifyOnOpen);

• 95:  nsEmbedStream::OpenStream(nsIURI *aBaseURI, const nsACString& aContentType)

• 158:   * @param openDialogObserver - an observer that will be notifed when the dialog is opened
• 162:   * @param notifyOnOpen - this indicates that the observer will be notified when the progress
• 163:   * dialog has been opened. If false is returned it means the observer
• 169:   in nsIObserver openDialogObserver,
• 173:   out boolean notifyOnOpen);

• 69:   * openStream was called twice without an intermediate closeStream.
• 71:   void openStream(in nsIURI aBaseURI, in ACString aContentType);
• 88:   * This method was called without a preceding openStream.

• 57:   NS_METHOD OpenStream (nsIURI *aBaseURI, const nsACString& aContentType);

• 188:   RegOpenKeyEx(HKEY_LOCAL_MACHINE, c_szMozillaControlKey, 0, KEY_READ, &hkey);
• 324:   RegOpenKeyEx(HKEY_CLASSES_ROOT, c_szMozCtlInProcServerKey, 0, KEY_ALL_ACCESS, &hkey);

• 70:   if (key.Open(HKEY_CLASSES_ROOT, _T("CLSID"), KEY_READ) != ERROR_SUCCESS)
• 72:   // Must fail if we can't even open this!
• 82:   LONG lResult = keyCLSID.Open(key, W2CT(szCLSID), KEY_READ);
• 97:   // Must fail if we can't open the category manager

• 240:   PRBool openInNewWindow = PR_FALSE;
• 258:   if (lFlags & navOpenInNewWindow)
• 260:   openInNewWindow = PR_TRUE;
• 302:   // No target nav? Open in new window
• 304:   openInNewWindow = PR_TRUE;
• 307:   // Open in new window
• 308:   if (openInNewWindow)
• 316:   lFlags &= ~(navOpenInNewWindow);
• 331:   // it could also open an instance of IE for such occasions.
• 334:   // Can't open a new window without client support

• 91:   hr = OpenURLStream(OLE2T(m_bstrSource), NULL, NULL, 0);
• 103:   OpenURLStream(OLE2T(m_bstrSource), NULL, NULL, 0);
• 437:   if (keyGeneral.Open(HKEY_LOCAL_MACHINE, szMainKey, KEY_READ) == ERROR_SUCCESS)
• 471:   if (key.Open(HKEY_LOCAL_MACHINE, szKey, KEY_READ) == ERROR_SUCCESS)
• 516:   if (keyNS.Open(HKEY_LOCAL_MACHINE, kNav4xKey, KEY_READ) == ERROR_SUCCESS)
• 523:   if (keyVersion.Open(keyNS, szVersion, KEY_READ) == ERROR_SUCCESS)
• 526:   if (keyMain.Open(keyVersion, _T("Main"), KEY_READ) == ERROR_SUCCESS)
• 550:   if (keyIE.Open(HKEY_LOCAL_MACHINE, kIEKey, KEY_READ) == ERROR_SUCCESS)
• 1012:  HRESULT nsPluginHostWnd::OpenURLStream(const TCHAR *szURL, void *pNotifyData, const void *pPostData, unsigned long nPostDataLength)
• 1014:   nsURLDataCallback::OpenURL(this, szURL, pNotifyData, pPostData, nPostDataLength);

• 253:   HRESULT OpenURLStream(const TCHAR *szURL, void *pNotifyData, const void *pPostData, unsigned long nDataLength);

• 176:   static HRESULT OpenURL(nsPluginHostWnd *pOwner, const TCHAR *szURL, void *pNotifyData, const void *pData, unsigned long nSize);

• 104:  HRESULT nsURLDataCallback::OpenURL(nsPluginHostWnd *pOwner, const TCHAR *szURL, void *pNotifyData, const void *pPostData, unsigned long nPostDataSize)
• 144:   // Open the URL
• 145:   hr = URLOpenStream(NULL, pThis->m_szURL, 0, static_cast<IBindStatusCallback*>(pThis));
• 344:   m_pTempFile = fopen(m_szTempFileName, "wb");
• 521:   // Notify the plugin that a stream has been opened

• 46:  _OpenURL(NPP npp, const char *szURL, const char *szTarget, void *pNotifyData, const char *pData, uint32 len, NPBool isFile)
• 159:   HRESULT hr = pWnd->OpenURLStream(A2CT(szURL), pNotifyData, postData, postDataLen);
• 167:   return _OpenURL(npp, relativeURL, target, NULL, NULL, 0, FALSE);
• 180:   return _OpenURL(npp, relativeURL, target, notifyData, NULL, 0, FALSE);
• 194:   return _OpenURL(npp, relativeURL, target, notifyData, buf, len, file);
• 207:   return _OpenURL(npp, relativeURL, target, NULL, buf, len, file);

• 459:   if (keyExplorer.Open(HKEY_LOCAL_MACHINE,
• 468:   if (keyCLSID.Open(keyExplorer, W2T(szCLSID), KEY_READ) == ERROR_SUCCESS)
• 491:   if (keyDeny.Open(HKEY_LOCAL_MACHINE, kControlsToDenyKey, KEY_READ) == ERROR_SUCCESS)
• 516:   if (keyAllow.Open(HKEY_LOCAL_MACHINE, kControlsToAllowKey, KEY_READ) == ERROR_SUCCESS)

• 998:   if (keyMimeDB.Open(HKEY_CLASSES_ROOT, _T("MIME\\Database\\Content Type"), KEY_READ) == ERROR_SUCCESS)
• 1001:   if (keyMimeType.Open(keyMimeDB, A2CT(mimeType), KEY_READ) == ERROR_SUCCESS)

• 508:   virtual /* [id][propput] */ HRESULT STDMETHODCALLTYPE put_opener(
• 514:   virtual /* [id][propget] */ HRESULT STDMETHODCALLTYPE get_opener(
• 547:   virtual /* [id] */ HRESULT STDMETHODCALLTYPE open(
• 1425:   virtual /* [id] */ HRESULT STDMETHODCALLTYPE open(
• 1841:   openAllowed);

• 398:   // For example, if someone opens the custom dlg and types "&P"

• 318:  /* void onStartURIOpen (in nsIURI aURI, out boolean aAbortOpen); */
• 319:  NS_IMETHODIMP CWebBrowserContainer::OnStartURIOpen(nsIURI *pURI, PRBool *aAbortOpen)
• 322:   NG_TRACE(_T("CWebBrowserContainer::OnStartURIOpen(...)\n"));
• 362:   *aAbortOpen = PR_TRUE;

• 136:   virtual HRESULT STDMETHODCALLTYPE open(BSTR url, VARIANT name, VARIANT features, VARIANT replace, IDispatch __RPC_FAR *__RPC_FAR *pomWindowResult);

• 103:   [helpstring("Open in new window")] navOpenInNewWindow = 0x0001,
• 108:   [helpstring("OpenBrowserBar")] navBrowserBar = 0x0020,
• 129:   [id(106), helpstring("Stops opening a file."), helpcontext(0x0000)]
• 191:   [id(300), helpstring("Exits application and closes the open document."), helpcontext(0x0000)]

• 192:   COMMAND_ID_HANDLER(ID_LINK_OPEN, OnLinkOpen)
• 193:   COMMAND_ID_HANDLER(ID_LINK_OPENINNEWWINDOW, OnLinkOpenInNewWindow)
• 345:   LRESULT OnLinkOpen(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled);
• 346:   LRESULT OnLinkOpenInNewWindow(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled);

• 164:   // ATL flags ensures the control opens with a window
• 614:   OPENFILENAME SaveFileName;
• 886:  LRESULT CMozillaBrowser::OnLinkOpen(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
• 907:  LRESULT CMozillaBrowser::OnLinkOpenInNewWindow(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
• 920:   CComVariant vFlags(navOpenInNewWindow);
• 938:   if (!uri.IsEmpty() && OpenClipboard())
• 1001:   // Attempt to open a named event for this process. If it's not there we
• 1006:   s_hHackedNonReentrancy = OpenEvent(EVENT_ALL_ACCESS, FALSE, szHackEvent);
• 1384:   if (cKey.Open(HKEY_LOCAL_MACHINE, kBrowserHelperObjectRegKey, KEY_ENUMERATE_SUB_KEYS) != ERROR_SUCCESS)

• 69:   nsCAutoString mOpenWith;
• 132:   CheckRadioButton(mHwndDlg, IDC_OPENWITHAPP, IDC_SAVETOFILE, IDC_SAVETOFILE);
• 136:   CheckRadioButton(mHwndDlg, IDC_OPENWITHAPP, IDC_SAVETOFILE, IDC_OPENWITHAPP);
• 168:   OPENFILENAME ofn;
• 171:   ofn.lStructSize = OPENFILENAME_SIZE_VERSION_400;
• 181:   if (GetOpenFileName(&ofn))
• 184:   mOpenWith = T2A(szPath);
• 186:   CheckRadioButton(mHwndDlg, IDC_OPENWITHAPP, IDC_SAVETOFILE, IDC_OPENWITHAPP);
• 396:  // m_Action.SetWindowText("[Opening file with:] " + m_FileName);
• 465:   nsCOMPtr<nsILocalFile> openWith;
• 466:   nsresult rv = NS_NewNativeLocalFile(dlg.mOpenWith, PR_FALSE, getter_AddRefs(openWith));
• 467:   return aLauncher->LaunchWithApplication(openWith, PR_FALSE);
• 487:   OPENFILENAME ofn;
• 490:   ofn.lStructSize = OPENFILENAME_SIZE_VERSION_400;

• 63:  #define IDC_OPENWITHAPP 300
• 90:  #define ID_FILE_OPEN 32776
• 91:  #define ID_LINK_OPEN 32776
• 92:  #define ID_FILE_OPENINNEWWINDOW 32777
• 93:  #define ID_LINK_OPENINNEWWINDOW 32777

• 754:  HRESULT STDMETHODCALLTYPE CIEHtmlDocument::open(BSTR url, VARIANT name, VARIANT features, VARIANT replace, IDispatch __RPC_FAR *__RPC_FAR *pomWindowResult)
• 756:   if (mDOMDocument == NULL || mDOMDocument->Open())

• 180:   FILE *f = fopen(pszFileName, "rb");

• 74:   // Open FILE handles to the various things that need to be generated
• 81:   fidl = fopen(filename.c_str(), "wt");
• 94:   fxpt = fopen(filename.c_str(), "wb");
• 103:   fstubh = fopen(stubh.c_str(), "wt");
• 104:   fstubc = fopen(stubc.c_str(), "wt");
• 108:   fprintf(stderr, "Opening TLB \"%s\"\n", inputTLB);
• 115:   fprintf(stderr, "Error: failed to open \"%s\"\n", inputTLB);

• 304:   FILE *fDest = fopen(sFileName, "wb");
• 307:   TraceProgress("Error: Could not open destination file");
• 335:   FILE *fSrc = fopen(sFileName, "rb");
• 338:   TraceProgress("Error: Could not open file");

• 76:   // Open the folder browser dialog

• 213:   // Open the folder browser dialog

• 112:   afx_msg void OnViewOpenInNewWindow();
• 114:   afx_msg void OnUpdateViewOpenInNewWindow(CCmdUI* pCmdUI);

• 14:  #define IDI_OPENFOLDER 131
• 72:  #define ID_VIEW_OPENLINKSINNEWWINDOWS 32797

• 109:   ON_COMMAND(ID_VIEW_OPENLINKSINNEWWINDOWS, OnViewOpenInNewWindow)
• 111:   ON_UPDATE_COMMAND_UI(ID_VIEW_OPENLINKSINNEWWINDOWS, OnUpdateViewOpenInNewWindow)
• 120:  #define IL_OPENFOLDER 1
• 163:   m_cImageList.Add(AfxGetApp()->LoadIcon(IDI_OPENFOLDER));
• 478:   CComVariant vFlags(m_bNewWindow ? navOpenInNewWindow : 0);
• 969:  void CBrowseDlg::OnViewOpenInNewWindow()
• 979:  void CBrowseDlg::OnUpdateViewOpenInNewWindow(CCmdUI* pCmdUI)

• 273:   moz_embed_signals[OPEN_URI] =
• 274:   g_signal_new("open_uri",
• 277:   G_STRUCT_OFFSET(GtkMozEmbedClass, open_uri),
• 786:   embedPrivate->OpenStream(base_uri, mime_type);
• 792:  gtk_moz_embed_open_stream(GtkMozEmbed *embed, const char *base_uri,
• 803:   embedPrivate->OpenStream(base_uri, mime_type);

• 94:   // set the chrome flag on the new window if it's a chrome open
• 95:   if (aChromeFlags & nsIWebBrowserChrome::CHROME_OPENAS_CHROME)

• 68:  EmbedContentListener::OnStartURIOpen(nsIURI *aURI,
• 69:   PRBool *aAbortOpen)
• 81:   moz_embed_signals[OPEN_URI], 0,
• 84:   *aAbortOpen = return_val;

• 95:   nsresult OpenStream (const char *aBaseURI, const char *aContentType);
• 155:   // the list of all open windows

• 437:   nsAutoPopupStatePusher popupStatePusher(piWin, openAllowed);
• 661:  EmbedPrivate::OpenStream(const char *aBaseURI, const char *aContentType)
• 674:   rv = wbStream->OpenStream(uri, nsDependentCString(aContentType));
• 716:   // creating a new window ) so it's OK to walk the list of open

• 65:   GTKF(gtk_moz_embed_open_stream) \

• 120:   gint (* open_uri) (GtkMozEmbed *embed, const char *aURI);
• 164:  GTKMOZEMBED_API(void, gtk_moz_embed_open_stream, (GtkMozEmbed *embed,
• 248:   GTK_MOZ_EMBED_FLAG_OPENASDIALOG = 1073741824U,
• 249:   GTK_MOZ_EMBED_FLAG_OPENASCHROME = 2147483648U

• 63:   OPEN_URI,

• 63:   GtkWidget *fileOpenNewBrowser;
• 92:  // the list of browser windows currently open
• 112:  static void menu_open_new_cb (GtkMenuItem *menuitem,
• 151:  static gint open_uri_cb (GtkMozEmbed *embed, const char *uri,
• 329:   browser->fileOpenNewBrowser =
• 330:   gtk_menu_item_new_with_label("Open New Browser");
• 332:   browser->fileOpenNewBrowser);
• 476:   // hook up to the open new browser activation
• 477:   g_signal_connect(GTK_OBJECT(browser->fileOpenNewBrowser), "activate",
• 478:   G_CALLBACK(menu_open_new_cb), browser);
• 531:   g_signal_connect(GTK_OBJECT(browser->mozEmbed), "open_uri",
• 532:   G_CALLBACK(open_uri_cb), browser);
• 535:   // and height args for a window.open in javascript
• 646:   gtk_moz_embed_open_stream(GTK_MOZ_EMBED(browser->mozEmbed),
• 665:  menu_open_new_cb (GtkMenuItem *menuitem, TestGtkBrowser *browser)
• 667:   g_print("opening new browser.\n");
• 683:   gtk_moz_embed_open_stream(GTK_MOZ_EMBED(browser->mozEmbed),
• 957:  open_uri_cb (GtkMozEmbed *embed, const char *uri, TestGtkBrowser *browser)
• 959:   g_print("open_uri_cb %s\n", uri);

• 71:   //gnome_mdi_open_toplevel(GNOME_MDI(mdi));

• 121:   nsCOMPtr<nsIWebBrowserChrome> mDependentParent; // opener (for dependent windows only)

• 85:  static nsresult OpenWebPage(const char * url);
• 252:   // Open the initial browser window
• 253:   OpenWebPage(gFirstURL);
• 269:   to a window creation function. This is how all new windows are opened,
• 289:  // FUNCTION: OpenWebPage()
• 291:  // PURPOSE: Opens a new browser dialog and starts it loading to the
• 294:  nsresult OpenWebPage(const char *url)
• 580:   OpenWebPage(gFirstURL);
• 1119:   // if opened as chrome, it'll be made visible after the chrome has loaded.
• 1121:   if (!(aChromeFlags & nsIWebBrowserChrome::CHROME_OPENAS_CHROME))

• 455:   (mChromeFlags & nsIWebBrowserChrome::CHROME_OPENAS_CHROME)) {

• 10:  #define MOZ_OpenURI 104
• 44:  #define MOZ_Open 32771

• 57:   EVT_MENU(XRCID("browser_open_in_new_window"),
• 58:   BrowserFrame::OnBrowserOpenLinkInNewWindow)
• 231:  void BrowserFrame::OnBrowserOpenLinkInNewWindow(wxCommandEvent & WXUNUSED(event))

• 126:   (mChromeFlags & nsIWebBrowserChrome::CHROME_OPENAS_CHROME)) {
• 462:  /* boolean onStartURIOpen (in nsIURI aURI); */
• 463:  NS_IMETHODIMP GeckoContainer::OnStartURIOpen(nsIURI *aURI, PRBool *_retval)

• 47:   void OnBrowserOpenLinkInNewWindow(wxCommandEvent & event);

• 354:  GeckoProtocolChannel::Open(nsIInputStream **_retval)
• 356:   NS_NOTREACHED("GeckoProtocolChannel::Open");
• 361:  GeckoProtocolChannel::AsyncOpen(nsIStreamListener *aListener, nsISupports *aContext)

• 133:   nsCOMPtr<nsIWebBrowserChrome> mDependentParent; // opener (for dependent windows only)

• 84:  static nsresult OpenWebPage(const char * url);
• 181:   // Open the initial browser window
• 182:   OpenWebPage(gFirstURL);
• 243:   // All the dialogs have been torn down so open new page
• 244:   OpenWebPage(gFirstURL);
• 259:   to a window creation function. This is how all new windows are opened,
• 284:  // FUNCTION: OpenWebPage()
• 286:  // PURPOSE: Opens a new browser dialog and starts it loading to the
• 289:  nsresult OpenWebPage(const char *url)
• 651:   OpenWebPage(gFirstURL);
• 1019:  // PURPOSE: Dialog handler procedure for the open uri dialog.
• 1219:   OpenWebPage(gFirstURL);
• 1436:   // if opened as chrome, it'll be made visible after the chrome has loaded.
• 1438:   if (!(aChromeFlags & nsIWebBrowserChrome::CHROME_OPENAS_CHROME))

• 118:   nsCOMPtr<nsIWebBrowserChrome> mDependentParent; // opener (for dependent windows only)

• 448:   (mChromeFlags & nsIWebBrowserChrome::CHROME_OPENAS_CHROME)) {

• 10:  #define MOZ_OpenURI 104
• 50:  #define MOZ_Open 32771

• 87:   // actual implementations of get/put dialogs using NSOpenPanel & NSSavePanel

• 258:   static PRBool GetIMEOpenState();
• 265:   static void SetIMEOpenState(PRBool aOpen);
• 378:   NS_IMETHOD SetIMEOpenState(PRBool aState);
• 379:   NS_IMETHOD GetIMEOpenState(PRBool* aState);

• 78:   // If > 0, the OS is indexing all the app's menus (triggered by opening
• 95:   nsEventStatus MenuOpened(const nsMenuEvent& aMenuEvent);
• 107:   PRBool OnOpen();
• 108:   PRBool OnOpened();

• 405:   NS_IMETHOD SetIMEOpenState(PRBool aState);
• 406:   NS_IMETHOD GetIMEOpenState(PRBool* aState);

• 444:   gint fd = g_file_open_tmp("XXXXXX.tmp", &buf, nsnull);
• 446:   return NS_ERROR_GFX_PRINTER_COULD_NOT_OPEN_FILE;
• 453:   return NS_ERROR_GFX_PRINTER_COULD_NOT_OPEN_FILE;
• 727:   return NS_ERROR_GFX_PRINTER_COULD_NOT_OPEN_FILE;

• 108:   case nsIFilePicker::modeOpen:
• 109:   case nsIFilePicker::modeOpenMultiple:
• 110:   action = GTK_FILE_CHOOSER_ACTION_OPEN;
• 115:   action = GTK_FILE_CHOOSER_ACTION_OPEN;
• 192:   : mMode(nsIFilePicker::modeOpen),
• 221:   if (mMode == nsIFilePicker::modeOpenMultiple) {
• 367:   if (mMode == nsIFilePicker::modeOpenMultiple) {
• 431:   ? GTK_STOCK_SAVE : GTK_STOCK_OPEN;
• 441:   if (action == GTK_FILE_CHOOSER_ACTION_OPEN || action == GTK_FILE_CHOOSER_ACTION_SAVE) {
• 453:   case nsIFilePicker::modeOpenMultiple:

• 60:  /* used with esd_open_sound */
• 77:  typedef int (*EsdOpenSoundType)(const char *host);
• 82:  typedef int (*EsdAudioOpenType) (void);
• 155:   EsdOpenSoundType EsdOpenSound =
• 156:   (EsdOpenSoundType) PR_FindFunctionSymbol(elib, "esd_open_sound");
• 157:   if (!EsdOpenSound) {
• 161:   esdref = (*EsdOpenSound)("localhost");
• 346:   /* open up connection to esd */
• 388:   EsdAudioOpenType EsdAudioOpen = (EsdAudioOpenType) PR_FindFunctionSymbol(elib, "esd_audio_open");
• 393:   !EsdAudioOpen || !EsdAudioWrite || !EsdAudioClose)
• 398:   fd = (*EsdAudioOpen)();

• 120:   { NS_VK_OPEN_BRACKET, GDK_bracketleft },
• 137:   { NS_VK_OPEN_BRACKET, GDK_braceleft },

• 560:   case eMetric_TreeOpenDelay:

• 299:  static PRBool gIMEVirtualKeyboardOpened = PR_FALSE;
• 3310:   if(!gIMEVirtualKeyboardOpened)
• 6240:  // GtkIMContextXIMs share XOpenIM connections and display closed signal
• 6274:   // opens (and doesn't close) new XOpenIM connections.
• 6645:  nsWindow::SetIMEOpenState(PRBool aState)
• 6651:  nsWindow::GetIMEOpenState(PRBool* aState)
• 6698:   gIMEVirtualKeyboardOpened = PR_TRUE;
• 6701:   gIMEVirtualKeyboardOpened = PR_FALSE;

• 309:   // if they are open, not on normal hover.
• 323:   aState->inHover = menuFrame->IsOpen();
• 343:   // A button with drop down menu open or an activated toggle button
• 354:   PRBool menuOpen = IsOpenButton(aFrame);
• 355:   aState->depressed = IsCheckedButton(aFrame) || menuOpen;
• 356:   // we must not highlight buttons with open drop down menus on hover.
• 357:   aState->inHover = aState->inHover && !menuOpen;
• 491:   case NS_THEME_TREEVIEW_TWISTY_OPEN:
• 1126:   case NS_THEME_TREEVIEW_TWISTY_OPEN:
• 1191:   aAttribute == nsWidgetAtoms::open ||
• 1245:   case NS_THEME_TREEVIEW_TWISTY_OPEN:

• 113:   else if (mMode == modeOpen) {
• 114:   btn1 = "&Open";
• 120:   else if( mMode == modeOpenMultiple ) {
• 191:   else if( mMode != modeOpenMultiple ) {
• 207:   else { /* here mMode is modeOpenMultiple */

• 90:   FILE *fp = fopen( data, "r" );
• 214:   FILE *fp = fopen( mTransportFile, "w" );

• 354:   case eMetric_TreeOpenDelay:

• 136:   // try to open the display
• 137:   mDisplay = XOpenDisplay(0);

• 236:   NS_IMETHOD SetIMEOpenState(PRBool aState);
• 237:   NS_IMETHOD GetIMEOpenState(PRBool* aState);

• 335:   if (::OpenClipboard(nativeWin)) {

• 110:   typedef HANDLE (WINAPI*OpenThemeDataPtr)(HWND hwnd, LPCWSTR pszClassList);
• 140:   static OpenThemeDataPtr openTheme;

• 195:   OPENFILENAMEW ofn;
• 243:   if (mMode == modeOpen) {
• 246:   result = ::GetOpenFileNameW(&ofn);
• 248:   else if (mMode == modeOpenMultiple) {
• 250:   result = ::GetOpenFileNameW(&ofn);
• 299:   if (mMode == modeOpenMultiple) {
• 301:   // from msdn.microsoft.com, "Open and Save As Dialog Boxes" section:

• 353:   case NS_THEME_TREEVIEW_TWISTY_OPEN:
• 414:   } else if (IsOpenButton(aFrame) ||
• 553:   if (IsOpenButton(aFrame)) {
• 788:   } else if (IsOpenButton(aFrame)) {
• 808:   PRBool isOpen = PR_FALSE;
• 829:   isOpen = (ccf && ccf->IsDroppedDown());
• 832:   isOpen = IsOpenButton(aFrame);
• 836:   if (isOpen) {
• 841:   * instead, we cheat -- if the dropdown is open, we always
• 863:   if (isOpen && (isHTML || isMenulist)) {
• 872:   // while the dropdown menu is open.
• 873:   if (isOpen) {
• 891:   PRBool isOpen = PR_FALSE;
• 898:   isOpen = menuFrame->IsOpen();
• 905:   if (isOpen)
• 1699:   aAttribute == nsWidgetAtoms::open ||
• 2051:   else if (IsOpenButton(aFrame))
• 2122:   PRBool isOpen = PR_FALSE;
• 2137:   isOpen = menuFrame->IsOpen();
• 2146:   if (isOpen)
• 2210:   PRBool isOpen = PR_FALSE;
• 2224:   isOpen = (ccf && ccf->IsDroppedDown());
• 2227:   isOpen = IsOpenButton(aFrame);
• 2231:   if (isOpen && (isHTML || isMenulist))

• 483:   case eMetric_TreeOpenDelay:

• 1559:  nsTextStore::SetIMEOpenState(PRBool aState)
• 1562:   ("TSF: SetIMEOpenState, state=%lu\n", aState));
• 1566:   GUID_COMPARTMENT_KEYBOARD_OPENCLOSE,
• 1577:  nsTextStore::GetIMEOpenState(void)
• 1581:   GUID_COMPARTMENT_KEYBOARD_OPENCLOSE,

• 69:  nsUXThemeData::OpenThemeDataPtr nsUXThemeData::openTheme = NULL;
• 102:   openTheme = (OpenThemeDataPtr)GetProcAddress(sThemeDLL, "OpenThemeData");
• 157:   sThemes[cls] = openTheme(NULL, GetClassName(cls));

• 927:  /* In some circumstances (opening dependent windows) it makes more sense
• 1170:   // XXX This fixes 50208 and we are leaving 51174 open to further investigate
• 1654:   if (splash && splash->IsOpen() && mWnd && bState &&
• 3672:   {"WM_QUERYOPEN", 0x0013},
• 4015:   PRFileDesc *prfd = PR_Open(filename, PR_CREATE_FILE | PR_APPEND | PR_WRONLY, 0777);
• 4725:   // Open the IME
• 4726:   ImmSetOpenStatus(IMEContext.get(), TRUE);
• 4735:   ImmSetOpenStatus(IMEContext.get(), FALSE);
• 6863:  NS_IMETHODIMP nsWindow::SetIMEOpenState(PRBool aState)
• 6866:   printf("SetIMEOpenState %s\n", (aState ? "Open" : "Close"));
• 6870:   nsTextStore::SetIMEOpenState(aState);
• 6875:   ::ImmSetOpenStatus(IMEContext.get(), aState ? TRUE : FALSE);
• 6881:  NS_IMETHODIMP nsWindow::GetIMEOpenState(PRBool* aState)
• 6885:   BOOL isOpen = ::ImmGetOpenStatus(IMEContext.get());
• 6886:   *aState = isOpen ? PR_TRUE : PR_FALSE;
• 6891:   *aState |= nsTextStore::GetIMEOpenState();
• 7427:   // chain from opening when a context menu is open
• 7485:   // open the dll dynamically

• 515:   case IMN_OPENCANDIDATE:
• 517:   ("IMM32: OnIMENotify, hWnd=%08x, IMN_OPENCANDIDATE, lParam=%08x\n",
• 520:   case IMN_OPENSTATUSWINDOW:
• 522:   ("IMM32: OnIMENotify, hWnd=%08x, IMN_OPENSTATUSWINDOW\n",
• 545:   case IMN_SETOPENSTATUS:
• 547:   ("IMM32: OnIMENotify, hWnd=%08x, IMN_SETOPENSTATUS\n",
• 582:   sIsStatusChanged = sIsStatusChanged || (wParam == IMN_SETOPENSTATUS);

• 723:   BOOL status = ::OpenPrinterW((LPWSTR)(aName),
• 770:   PR_PL(("***** nsDeviceContextSpecWin::GetDataFromPrinter - Couldn't open printer: [%s]\n", NS_ConvertUTF16toUTF8(aName).get()));

• 115:   static void SetIMEOpenState(PRBool);
• 116:   static PRBool GetIMEOpenState(void);

• 128:   rv = mChannel->Open(getter_AddRefs(mInputStream));

• 59:   mMode(nsIFilePicker::modeOpen)
• 190:   if (mMode == nsIFilePicker::modeOpenMultiple) {
• 208:   case nsIFilePicker::modeOpen:
• 210:   case nsIFilePicker::modeOpenMultiple:

• 58:  /* used with esd_open_sound */
• 73:  typedef int (*EsdOpenSoundType)(const char *host);
• 78:  typedef int (*EsdAudioOpenType) (void);
• 116:   /* we don't need to do esd_open_sound if we are only going to play files
• 124:   EsdOpenSoundType EsdOpenSound;
• 129:   EsdOpenSound = (EsdOpenSoundType) PR_FindFunctionSymbol(elib, "esd_open_sound");
• 131:   if (!EsdOpenSound)
• 134:   esdref = (*EsdOpenSound)("localhost");
• 290:   /* open up connection to esd */
• 332:   EsdAudioOpenType EsdAudioOpen = (EsdAudioOpenType) PR_FindFunctionSymbol(elib, "esd_audio_open");
• 337:   !EsdAudioOpen || !EsdAudioWrite || !EsdAudioClose)
• 342:   fd = (*EsdAudioOpen)();

• 341:   "eMetric_TreeOpenDelay",

• 168:   { NS_VK_OPEN_BRACKET, Qt::Key_ParenLeft },

• 102:   panel_mode = B_OPEN_PANEL;
• 104:   else if (mMode == modeOpen) {
• 106:   panel_mode = B_OPEN_PANEL;
• 108:   else if (mMode == modeOpenMultiple) {
• 110:   panel_mode = B_OPEN_PANEL;
• 178:   if ((mMode == modeOpen || mMode == modeOpenMultiple || mMode == modeGetFolder) && ppanel->IsOpenSelected()) {
• 179:   BList *list = ppanel->OpenRefs();
• 189:   // to assign also first list element to mFile even in openMultiple case ?
• 190:   if (mMode == modeOpenMultiple) {
• 391:   , mOpenRefs()
• 399:   if ( mode == B_OPEN_PANEL && node_flavors == B_DIRECTORY_NODE )
• 401:   // Add a 'Select <dirname>' button to the open dialog
• 433:   int count = mOpenRefs.CountItems();
• 435:   delete mOpenRefs.ItemAt(i);
• 446:   case B_REFS_RECEIVED: // open
• 457:   mOpenRefs.AddItem((void *) path);
• 463:   mSelectedActivity = OPEN_SELECTED;
• 473:   mOpenRefs.AddItem((void *) path);
• 474:   mSelectedActivity = OPEN_SELECTED;

• 98:   FILE *fp = fopen(soundFilename.get(), "wb+");

• 46:  // XXX adding mLastUsedDirectory and code for handling last used folder on File Open/Save
• 129:   virtual bool IsOpenSelected() {
• 130:   return (SelectedActivity() == OPEN_SELECTED);
• 140:   virtual BList *OpenRefs() { return &mOpenRefs; }
• 146:   OPEN_SELECTED = 1,
• 158:   BList mOpenRefs;

• 415:   case eMetric_TreeOpenDelay:

• 129:   * Closes the printmanager if it is open.

• 2132:   { NS_VK_OPEN_BRACKET, 0x31 },

• 75:   * Closes the printmanager if it is open.

• 101:  WIDGET_ATOM(open, "open") // Whether or not a menu, tree, etc. is open

• 141:   PRBool IsOpenButton(nsIFrame* aFrame) {
• 142:   return CheckBooleanAttr(aFrame, nsWidgetAtoms::open);

• 135:   NS_IMETHOD SetIMEOpenState(PRBool aState) { return NS_ERROR_NOT_IMPLEMENTED; }
• 136:   NS_IMETHOD GetIMEOpenState(PRBool* aState) { return NS_ERROR_NOT_IMPLEMENTED; }
• 233:  // menu popup is already open. The expected behaviour is to close the popup.
• 236:  // event will then get targeted at the menu label causing the menu to open
• 239:  // reopening while processing the mouse event.

• 100:   { "ui.treeOpenDelay",
• 101:   eMetric_TreeOpenDelay, PR_FALSE, nsLookAndFeelTypeInt, 0 },

• 176:   return wwatch->OpenWindow(parent,

• 368:   if (WinOpenClipbrd(0/*hab*/)) {
• 430:   if (WinOpenClipbrd(0/*hab*/)) {

• 40:  // Define so header files for openfilename are included
• 158:   filedlg.fl = FDS_OPEN_DIALOG | FDS_CENTER;
• 182:   } else if (mMode == modeOpenMultiple) {
• 183:   filedlg.fl |= FDS_MULTIPLESEL | FDS_OPEN_DIALOG;
• 185:   filedlg.fl |= FDS_OPEN_DIALOG;
• 290:   if (mMode == modeOpenMultiple) {
• 822:   if (pfiledlg->fl & FDS_OPEN_DIALOG) {

• 76:  HMMIO (*APIENTRY _mmioOpen)(PSZ, PMMIOINFO, ULONG);
• 113:   ulrc = DosQueryProcAddr(sHModMMIO, 0L, "mmioOpen", (PFN *)&_mmioOpen);
• 169:   // find one that can open the file.
• 187:   // faulty VORBIS/FLAC/MP3 IOProcs that will open any format.
• 206:   HMMIO hmmio= _mmioOpen(NULL, &mi, MMIO_READ);
• 267:   ulrc = DosOpen(args.pszFilename, &hf, &ulAction, 0, FILE_NORMAL,
• 268:   OPEN_ACTION_OPEN_IF_EXISTS | OPEN_ACTION_FAIL_IF_NEW,
• 269:   OPEN_ACCESS_READONLY | OPEN_SHARE_DENYNONE,
• 273:   printf("playSound: could not open the sound file \"%s\" (%ld)\n",
• 303:   hmmio = _mmioOpen(NULL, &mi, MMIO_READ | MMIO_DENYWRITE);
• 309:   printf("playSound: mmioOpen failed, cannot play sound from \"%s\" (%ld)\n",
• 312:   printf("playSound: mmioOpen failed, cannot play sound buffer (%ld)\n",
• 319:   // open the sound device
• 320:   MCI_OPEN_PARMS mop;
• 324:   ulrc = _mciSendCommand(0, MCI_OPEN,
• 325:   MCI_OPEN_MMIO | MCI_OPEN_TYPE_ID | MCI_OPEN_SHAREABLE | MCI_WAIT,
• 331:   printf("playSound: mciSendCommand with MCI_OPEN_MMIO returned %ld: %s\n",

• 164:   dragitem.fsControl = DC_OPEN;
• 531:   if (NS_FAILED(file->OpenANSIFileDesc("wb+", &fp)))
• 560:   if (NS_FAILED(file->OpenANSIFileDesc("wb+", &fp)))
• 597:   if (NS_FAILED(file->OpenANSIFileDesc("wb+", &fp)))
• 1647:   FILE *fp = fopen(pszPath, "r");

• 62:  #ifndef OPENFILENAME
• 63:  /* OPENFILENAME struct flags
• 107:  } OPENFILENAME, *POPENFILENAME, *LPOPENFILENAME;
• 109:  extern "C" BOOL APIENTRY DaxOpenSave(BOOL, LONG *, LPOPENFILENAME, PFNWP);

• 191:  #define RWSCMD_OPEN 2
• 194:  #define RWSCMD_OPENUSING 5

• 284:   DEVOPENSTRUC dop;
• 296:   hdc = ::DevOpenDC(0, OD_INFO, "*", 9, (PDEVOPENDATA) &dop, NULLHANDLE);
• 357:  HDC PrnOpenDC( PRTQUEUE *pInfo, PSZ pszApplicationName, int copies, int destination, char *file )
• 363:   DEVOPENSTRUC dop;
• 394:   hdc = ::DevOpenDC( 0, dcType, "*", 9, (PDEVOPENDATA) &dop, NULLHANDLE);
• 400:   printf ("!ERROR! - Can't open DC for printer %04lX\a\n", ErrorCode);

• 90:  HDC PrnOpenDC( PRTQUEUE *pPrintQueue, PSZ pszApplicationName, int copies, int destination, char *file);

• 363:   case eMetric_TreeOpenDelay:

• 318:   // if the default view is OPEN_SETTINGS ('2'),
• 319:   // change it to OPEN_RUNNING ('4')
• 331:   // for default view values less than OPEN_USER, see if there
• 345:   // (if chosen, the WPS will open the file's Properties notebook)
• 534:  // causes the WPS to open a file using the program specified by AppPath;
• 538:  nsRwsService::OpenWithAppHandle(const char *aFilePath, PRUint32 aAppHandle)
• 548:   RWSP_CMD, RWSCMD_OPENUSING,
• 553:   ERRMSG(rc, "RWSCMD_OPENUSING")
• 563:  // causes the WPS to open a file using the program specified by AppPath;
• 567:  nsRwsService::OpenWithAppPath(const char *aFilePath, const char *aAppPath)
• 577:   RWSP_CMD, RWSCMD_OPENUSING,
• 582:   ERRMSG(rc, "RWSCMD_OPENUSING")
• 732:   FILE *fp = fopen(pathStr.get(), "wb+");

• 2455:   // a WM_OPEN message. When this happens we do not get a
• 3708:   case 0x1A: rc = NS_VK_OPEN_BRACKET; break;

• 327:   * Closes the printmanager if it is open.
• 414:   mPrintDC = PrnOpenDC(mQueue, "Mozilla", numCopies, printerDest, filename);

• 119:   * Opens a file using the specified program file. The effect
• 125:   void openWithAppPath(in string aFilePath, in string aAppPath);
• 128:   * Opens a file using the specified WPS object handle. The effect
• 134:   void openWithAppHandle(in string aFilePath, in unsigned long aAppHandle);

• 50:   const short modeOpen = 0; // Load a file or directory
• 53:   const short modeOpenMultiple= 3; // Load multiple files
• 120:   * Set the directory that the file open/save dialog initially displays
• 144:   * only works in the modeOpenMultiple mode

• 216:   eMetric_SubmenuDelay, // delay before submenus open
• 232:   eMetric_TreeOpenDelay, // delay for opening spring loaded folders

• 58:   * Retrieve the widgets for open menus are store them in the array
• 60:   * for example, if a context menu is open, return only the number of menus
• 67:   * Adjust the position of open panels when a window is moved or resized.

• 1491:  #define NS_VK_OPEN_BRACKET nsIDOMKeyEvent::DOM_VK_OPEN_BRACKET

• 957:   * Following methods relates to IME 'Opened'/'Closed' state.
• 958:   * 'Opened' means the user can input any character. I.e., users can input Japanese
• 961:   * non-IME environment. The user can change the state to 'Opened'.
• 967:   * Set the state to 'Opened' or 'Closed'.
• 968:   * If aState is TRUE, IME open state is set to 'Opened'.
• 971:   NS_IMETHOD SetIMEOpenState(PRBool aState) = 0;
• 974:   * Get IME is 'Opened' or 'Closed'.
• 975:   * If IME is 'Opened', aState is set PR_TRUE.
• 978:   NS_IMETHOD GetIMEOpenState(PRBool* aState) = 0;
• 991:   * 'Disabled' means the user cannot use IME. So, the open state should be

• 95:   * @param aDocShell (out-param) the DocShell that the request was opened on
• 96:   * @param aRequest the request that was opened

• 186:   rv = NS_OpenURI(getter_AddRefs(in), uri);
• 248:   nsPropertyEnumeratorByURL* propEnum =
• 251:   if (!propEnum) return NS_ERROR_OUT_OF_MEMORY;
• 253:   NS_ADDREF(*aResult = propEnum);

• 126:   // We don't use NS_OpenURI because we want to tweak the channel
• 135:   rv = channel->Open(getter_AddRefs(in));
• 140:   NS_ASSERTION(NS_SUCCEEDED(rv) && in, "Error in OpenBlockingStream");
• 332:   nsCOMPtr<nsISimpleEnumerator> propEnumerator;
• 333:   rv = mProps->Enumerate(getter_AddRefs(propEnumerator));
• 341:   rv = propEnumerator->GetNext(getter_AddRefs(supports));
• 357:   rv = propEnumerator->HasMoreElements(&hasMore);

• 74:  #define UC_PS 0x00200000 /* Punctuation, Open */
• 150:  #define ucisopenpunct(cc) ucisprop(cc, UC_PS, 0)

• 96:   kUGDC_Ps = (kUGenCategory_Punctuation << 4) | 3, // Punctuation, Open - return only when kUGDC_DetailPunctuation bit is set

• 75:   NS_ASSERTION(info , "cannot open properties file");

• 84:   NS_ASSERTION(info , "cannot open properties file");

• 91:   NS_ASSERTION(info , "cannot open properties file");

• 54:  #include <iconv.h> // iconv_open, iconv, iconv_close
• 152:   mConverter = iconv_open(to, from);

• 488:   FILE * f = fopen(aFile, "rb");
• 490:   printf("ERROR at opening file: \"%s\".\n", aFile);

• 149:   infile = fopen(argv[5], "rb");
• 153:   fprintf(stderr,"cannot open file %s\n", argv[5]);

• 161:   fin = infile = fopen(argv[5], "rb");
• 165:   fprintf(stderr,"cannot open input file %s\n", argv[5]);
• 173:   fout = outfile = fopen(argv[6], "ab");
• 177:   fprintf(stderr,"cannot open output file %s\n", argv[6]);

• 90:   1: Open parenthesis
• 188:   [c]. Based on open parenthesis class (1), but it is not breakable after
• 348:   0: Open parenthesis
• 357:   9: Open parentheses like Character (See bug 389056)
• 365:  #define CLASS_OPEN 0x00
• 374:  #define CLASS_OPEN_LIKE_CHARACTER 0x09
• 387:  #define U_OPEN_SINGLE_QUOTE PRUnichar(0x2018)
• 388:  #define U_OPEN_DOUBLE_QUOTE PRUnichar(0x201C)
• 389:  #define U_OPEN_GUILLEMET PRUnichar(0x00AB)
• 397:   (c) == U_OPEN_SINGLE_QUOTE || \
• 398:   (c) == U_OPEN_DOUBLE_QUOTE || \
• 399:   (c) == U_OPEN_GUILLEMET)
• 680:   // Don't return CLASS_OPEN/CLASS_CLOSE if aState.UseJISX4051 is FALSE.
• 712:   return CLASS_OPEN;
• 718:   return CLASS_OPEN;
• 721:   return CLASS_OPEN;
• 728:   } else if (cur == U_OPEN_SINGLE_QUOTE ||
• 729:   cur == U_OPEN_DOUBLE_QUOTE ||
• 730:   cur == U_OPEN_GUILLEMET) {
• 731:   // for CJK usage, we treat these as openers to allow a break before them,
• 735:   return CLASS_OPEN;

• 230:   // skip opening quote
• 236:   // skip opening quote

• 23:  #define ENFILE 23 /* Too many open files in system */
• 24:  #define EMFILE 24 /* Too many open files */

• 467:   rv = storage->OpenUnsharedDatabase(cookieFile, getter_AddRefs(mDBConn));
• 546:   // open in exclusive mode for performance
• 666:   // open the connection to the on-disk DB

• 108:   serverFD = PR_OpenUDPSocket(PR_AF_INET);
• 109:   UDP_ASSERT(serverFD, "Cannot open UDP socket for listening");
• 144:   rv = transport->OpenOutputStream(nsITransport::OPEN_BLOCKING,
• 146:   UDP_ASSERT_NSRESULT("Cannot open output stream");
• 167:   rv = transport->OpenInputStream(nsITransport::OPEN_BLOCKING,
• 169:   UDP_ASSERT_NSRESULT("Cannot open input stream");

• 83:   printf( "Calling NS_OpenURI...\n" );
• 84:   nsresult rv = NS_OpenURI( getter_AddRefs( result ), uri, 0 );
• 87:   printf( "...NS_OpenURI completed OK\n" );
• 89:   printf( "%s %d: NS_OpenURI failed, rv=0x%08X\n",
• 136:   // Open output file.
• 139:   mFile = fopen( fileName, "wb" );
• 196:  // thread), opens a channel, and does AsyncRead to it.

• 82:  TestOpenInputStream(const char* url)
• 96:   rv = channel->Open(getter_AddRefs(in));
• 98:   fprintf(stdout, "failed to OpenInputStream for %s\n", url);
• 227:   rv = channel->AsyncOpen(nsnull, listener);
• 264:   rv = TestOpenInputStream(argv[1]);
• 265:   NS_ASSERTION(NS_SUCCEEDED(rv), "TestOpenInputStream failed");

• 165:   RETURN_IF_FAILED(rv, "NS_OpenURI");
• 167:   rv = chan->AsyncOpen(listener, nsnull);
• 168:   RETURN_IF_FAILED(rv, "AsyncOpen");

• 161:   rv = srcTrans->OpenInputStream(0, 0, 0, getter_AddRefs(inStr));
• 165:   rv = destTrans->OpenOutputStream(0, 0, 0, getter_AddRefs(outStr));
• 278:   rv = destTransport->OpenOutputStream(nsITransport::OPEN_BLOCKING, 100, 10, getter_AddRefs(destOut));

• 190:   rv = chan->AsyncOpen(new MyListener(), nsnull);

• 86:   rv = trans->OpenInputStream(nsITransport::OPEN_BLOCKING, 0, 0, getter_AddRefs(input));
• 90:   rv = trans->OpenOutputStream(nsITransport::OPEN_BLOCKING, 0, 0, getter_AddRefs(output));

• 51:   * Test synchronous Open.
• 74:   printf("Usage: TestOpen url filename\nLoads a URL using ::Open, writing it to a file\n");
• 84:   rv = NS_OpenURI(getter_AddRefs(stream), uri);
• 85:   RETURN_IF_FAILED(rv, "NS_OpenURI");
• 87:   FILE* outfile = fopen(argv[2], "wb");
• 89:   printf("error opening %s\n", argv[2]);

• 65:   * This test program loads a file into the memory cache (using OpenOutputStream),
• 108:   mFile = fopen(mFilename, "w");
• 170:   rv = session->OpenCacheEntry(nsDependentCString(filename),
• 184:   rv = transport->OpenOutputStream(0, (PRUint32) -1, 0, getter_AddRefs(os));
• 196:   FILE *file = fopen(filename, "r");

• 629:   LOG(("ERROR: NS_OpenURI failed for %s [rv=%x]\n", aUrlString, rv));
• 684:   rv = pChannel->AsyncOpen(listener, // IStreamListener consumer
• 691:   LOG(("ERROR: AsyncOpen failed [rv=%x]\n", rv));
• 738:   fd = PR_Open(aFileName, PR_RDONLY, 777);

• 23:   rv = NS_OpenURI(getter_AddRefs(stream), uri, gIOService);
• 26:   fprintf(stderr, "*** failed opening %s [rv=%x]\n", spec.get(), rv);
• 123:   nsresult rv = NS_OpenURI(listener, nsnull, uri, gIOService);
• 128:   printf(">> NS_OpenURI failed [rv=%x]\n", rv);
• 146:   FILE *fp = fopen(fname, "r");
• 148:   printf("failed opening file: %s\n", fname);

• 159:   * create transport, open streams, and close
• 177:   rv = transport->OpenInputStream(inFlags, 0, 0, getter_AddRefs(in));
• 182:   rv = transport->OpenOutputStream(outFlags, 0, 0, getter_AddRefs(out));
• 213:   rv = transport->OpenInputStream(inFlags, 0, 0, getter_AddRefs(in));
• 218:   rv = transport->OpenOutputStream(outFlags, 0, 0, getter_AddRefs(out));
• 275:   LOG(("flags = { OPEN_UNBUFFERED, OPEN_UNBUFFERED }\n"));
• 277:   nsITransport::OPEN_UNBUFFERED,
• 278:   nsITransport::OPEN_UNBUFFERED);
• 281:   LOG(("flags = { OPEN_BUFFERED, OPEN_UNBUFFERED }\n"));
• 283:   0 /* nsITransport::OPEN_BUFFERED */,
• 284:   nsITransport::OPEN_UNBUFFERED);
• 287:   LOG(("flags = { OPEN_UNBUFFERED, OPEN_BUFFERED }\n"));
• 289:   nsITransport::OPEN_UNBUFFERED,
• 290:   0 /*nsITransport::OPEN_BUFFERED */);
• 293:   LOG(("flags = { OPEN_BUFFERED, OPEN_BUFFERED }\n"));
• 295:   0 /*nsITransport::OPEN_BUFFERED */,
• 296:   0 /*nsITransport::OPEN_BUFFERED */);
• 307:   LOG(("flags = { OPEN_UNBUFFERED, OPEN_UNBUFFERED }\n"));
• 309:   nsITransport::OPEN_UNBUFFERED,
• 310:   nsITransport::OPEN_UNBUFFERED);
• 313:   LOG(("flags = { OPEN_BUFFERED, OPEN_UNBUFFERED }\n"));
• 315:   0 /* nsITransport::OPEN_BUFFERED */,
• 316:   nsITransport::OPEN_UNBUFFERED);
• 319:   LOG(("flags = { OPEN_UNBUFFERED, OPEN_BUFFERED }\n"));
• 321:   nsITransport::OPEN_UNBUFFERED,
• 322:   0 /*nsITransport::OPEN_BUFFERED */);
• 325:   LOG(("flags = { OPEN_BUFFERED, OPEN_BUFFERED }\n"));
• 327:   0 /*nsITransport::OPEN_BUFFERED */,
• 328:   0 /*nsITransport::OPEN_BUFFERED */);

• 114:   rv = session->OpenCacheEntry(NS_LITERAL_CSTRING("non-existent entry"),
• 119:   printf("OpenCacheEntry(ACCESS_READ) returned: %x for non-existent entry\n", rv);
• 125:   rv = session->OpenCacheEntry(cacheKey,
• 130:   printf("OpenCacheEntry(ACCESS_READ_WRITE) failed: %x\n", rv);
• 146:   rv = session->OpenCacheEntry(cacheKey,
• 151:   printf("OpenCacheEntry(ACCESS_READ_WRITE #2) failed: %x", rv);
• 171:   rv = session->OpenCacheEntry(cacheKey,
• 176:   printf("OpenCacheEntry(ACCESS_WRITE) failed: %x", rv);

• 350:   rv = transport->OpenOutputStream(0, 0, 0, getter_AddRefs(os));
• 352:   LOG(("OpenOutputStream failed [rv=%x]\n", rv));
• 364:   rv = transport->OpenInputStream(0, 0, 0, getter_AddRefs(is));
• 366:   LOG(("OpenInputStream failed [rv=%x]\n", rv));

• 180:   FILE *testfile = fopen(gFileIO, "rt");
• 183:   fprintf(stderr, "Cannot open testfile: %s\n", gFileIO);

• 77:   rv = blockFile->Open(localFile, 256);
• 79:   printf("Test %d: failed (Open returned: 0x%.8x)\n", testNumber, rv);
• 230:   // Need nsILocalFile to open
• 252:   // Test 1: Open non-existing file
• 254:   rv = blockFile->Open(localFile, 256);
• 256:   printf("Test 1: failed (Open returned: 0x%.8x)\n", rv);
• 270:   // Test 2: Open existing file (with no allocation)
• 272:   rv = blockFile->Open(localFile, 256);
• 274:   printf("Test 2: failed (Open returned: 0x%.8x)\n", rv);
• 288:   // Test 3: Open existing file (bad format) size < kBitMapBytes
• 305:   rv = stream->Open(localFile);
• 308:   printf("Test 3 failed (stream->Open returned: 0x%.8x)\n", rv);
• 328:   rv = blockFile->Open(localFile, 256);
• 330:   printf("Test 3: failed (Open erroneously succeeded)\n", rv);
• 340:   // Test 4: Open non-existing file (again)
• 350:   rv = blockFile->Open(localFile, 256);
• 352:   printf("Test 4: failed (Open returned: 0x%.8x)\n", rv);
• 532:   rv = blockFile->Open(localFile, 256);
• 534:   printf("Test 13: failed (Open returned: 0x%.8x)\n", rv);
• 654:   // Test 14: ValidateFile (open existing file w/size < allocated blocks
• 656:   rv = blockFile->Open(localFile, 256);
• 658:   printf("Test 14: failed (Open erroneously succeeded)\n");
• 686:   rv = blockFile->Open(localFile, 256);
• 688:   printf("Test 16: failed (Open returned: 0x%.8x)\n", rv);
• 832:   // Test 18: ValidateFile (open existing file with blocks allocated)
• 834:   rv = blockFile->Open(localFile, 256);
• 836:   printf("Test 18: failed (Open returned: 0x%.8x)\n", rv);

• 89:   rv = trans->OpenOutputStream(nsITransport::OPEN_BLOCKING, 100, 10, getter_AddRefs(output));

• 334:   rv = chan->AsyncOpen(listener, myBool);
• 335:   RETURN_IF_FAILED(rv, "AsyncOpen");
• 379:   RETURN_IF_FAILED(rv, "NS_OpenURI");
• 385:   rv = chan->AsyncOpen(listener, nsnull);
• 386:   RETURN_IF_FAILED(rv, "AsyncOpen");

• 85:   ret = channel->Open(&in);
• 113:   nsCOMPtr<nsISimpleEnumerator> propEnum;
• 114:   ret = props->Enumerate(getter_AddRefs(propEnum));
• 126:   while (NS_SUCCEEDED(propEnum->HasMoreElements(&hasMore)) &&
• 129:   ret = propEnum->GetNext(getter_AddRefs(sup));

• 175:   // Open the input stream:
• 183:   // Open the output stream:
• 277:   rv = inCh->Open(getter_AddRefs(inStr));
• 283:   //rv = outCh->OpenOutputStream(0, -1, 0, getter_AddRefs(outStr));

• 88:   PRFileDesc* fd = PR_Open(name, PR_WRONLY | PR_CREATE_FILE | PR_TRUNCATE, 0664);

• 79:   rv = chan->AsyncOpen(loader, nsnull);

• 302:   return channel->AsyncOpen(static_cast<nsIStreamListener*>(consumer), contextSup);

• 191:   channel->AsyncOpen(listener, nsnull);

• 91:   rv = NS_OpenURI(getter_AddRefs(c[i].channel), c[i].uri, nsnull, nsnull);
• 92:   RETURN_IF_FAILED(rv, "NS_OpenURI");
• 96:   httpChannel->SetOpenHasEventQueue(PR_FALSE);
• 106:   rv = c[i].channel->Open(getter_AddRefs(c[i].inputStream));
• 107:   RETURN_IF_FAILED(rv, "nsIChannel::OpenInputStream");

• 68:   virtual nsresult OpenContentStream(PRBool async, nsIInputStream **result,

• 168:   // if so, open it & get its size
• 170:   rv = os2File->OpenNSPRFileDesc(PR_RDONLY, 0, &file);

• 310:  nsFileChannel::OpenContentStream(PRBool async, nsIInputStream **result,

• 72:   * guaranteed to reference a resource that exists (ie. opening a channel to

• 195:   nsresult OpenCacheEntry(PRBool offline, PRBool *delayed);
• 196:   nsresult OpenOfflineCacheEntryForWriting();
• 322:   PRUint32 mWasOpened : 1;

• 107:  // a transaction with this caps flag will, upon opening a new connection,

• 54:   // anonymity of the connection is setup later from nsHttpChannel::AsyncOpen

• 471:   // next open the socket streams
• 473:   rv = strans->OpenOutputStream(nsITransport::OPEN_UNBUFFERED, 0, 0,
• 477:   rv = strans->OpenInputStream(nsITransport::OPEN_UNBUFFERED, 0, 0,

• 118:   , mWasOpened(PR_FALSE)
• 296:   // true when called from AsyncOpen
• 313:   // open a cache entry for this channel...
• 314:   rv = OpenCacheEntry(offline, &delayed);
• 317:   LOG(("OpenCacheEntry failed [rv=%x]\n", rv));
• 319:   // we must fail if we were unable to open a cache entry.
• 331:   // if cacheForOfflineUse has been set, open up an offline cache
• 334:   rv = OpenOfflineCacheEntryForWriting();
• 1132:   // install cache listener if we still have a cache entry open
• 1270:   // open new channel
• 1271:   rv = newChannel->AsyncOpen(mListener, mListenerContext);
• 1603:   rv = newChannel->AsyncOpen(mListener, mListenerContext);
• 1634:  nsHttpChannel::OpenCacheEntry(PRBool offline, PRBool *delayed)
• 1641:   LOG(("nsHttpChannel::OpenCacheEntry [this=%x]", this));
• 1644:   NS_PRECONDITION(!mCacheEntry, "cache entry already open");
• 1726:   // to open the cache entry asynchronously.
• 1744:   // we'll try to synchronously open the cache entry... however,
• 1746:   // try asynchronously opening the cache entry.
• 1748:   // We open with ACCESS_READ only, because we don't want to
• 1752:   rv = session->OpenCacheEntry(cacheKey,
• 1806:   // We successfully opened an offline cache session and the entry,
• 1817:   rv = session->OpenCacheEntry(cacheKey, accessRequested, PR_FALSE,
• 1833:   rv = session->AsyncOpenCacheEntry(cacheKey, accessRequested, this);
• 1840:   LOG(("nsHttpChannel::OpenCacheEntry [this=%x grantedAccess=%d]", this, mCacheAccess));
• 1847:  nsHttpChannel::OpenOfflineCacheEntryForWriting()
• 1851:   LOG(("nsHttpChannel::OpenOfflineCacheEntryForWriting [this=%x]", this));
• 1854:   NS_PRECONDITION(!mOfflineCacheEntry, "cache entry already open");
• 1895:   rv = session->OpenCacheEntry(cacheKey, nsICache::ACCESS_READ_WRITE,
• 1998:  // CheckCache is called from Connect after a cache entry has been opened for
• 2013:   // Don't proceed unless we have opened a cache entry for reading.
• 2339:   // since AsyncOpen may not have returned yet. Make sure there is a Location
• 2382:   // open input stream for reading...
• 2384:   rv = mCacheEntry->OpenInputStream(0, getter_AddRefs(stream));
• 2652:  // Open an output stream to the cache entry and insert a listener tee into
• 2665:   rv = mCacheEntry->OpenOutputStream(offset, getter_AddRefs(out));
• 2698:   rv = mOfflineCacheEntry->OpenOutputStream(0, getter_AddRefs(out));
• 2979:   rv = newChannel->AsyncOpen(mListener, mListenerContext);
• 4123:   if (mListener || mWasOpened) {
• 4192:  nsHttpChannel::Open(nsIInputStream **_retval)
• 4194:   NS_ENSURE_TRUE(!mWasOpened, NS_ERROR_IN_PROGRESS);
• 4195:   return NS_ImplementChannelOpen(this, _retval);
• 4199:  nsHttpChannel::AsyncOpen(nsIStreamListener *listener, nsISupports *context)
• 4201:   LOG(("nsHttpChannel::AsyncOpen [this=%x]\n", this));
• 4205:   NS_ENSURE_TRUE(!mWasOpened, NS_ERROR_ALREADY_OPENED);
• 4214:   // Start a DNS lookup very early in case the real open is queued the DNS can
• 4245:   mWasOpened = PR_TRUE;
• 5405:   // we must fail if we were unable to open a cache entry.
• 5484:   NS_ENSURE_TRUE(!mWasOpened, NS_ERROR_ALREADY_OPENED);
• 5507:   NS_ENSURE_TRUE(!mWasOpened, NS_ERROR_ALREADY_OPENED);
• 5523:   NS_ENSURE_TRUE(!mWasOpened, NS_ERROR_ALREADY_OPENED);
• 5739:   // The logic below deviates from the original logic in OpenCacheEntry on
• 5759:   rv = session->OpenCacheEntry(tmpCacheKey, nsICache::ACCESS_READ,

• 59:   * Modifying request parameters after asyncOpen has been called is an error.
• 66:   * This attribute may only be set before the channel is opened.
• 73:   * @throws NS_ERROR_IN_PROGRESS if set after the channel has been opened.
• 82:   * This attribute may only be set before the channel is opened.
• 90:   * @throws NS_ERROR_IN_PROGRESS if set after the channel has been opened.
• 112:   * This method may only be called before the channel is opened.
• 131:   * opened.
• 156:   * This attribute may only be set before the channel is opened.
• 158:   * @throws NS_ERROR_FAILURE if set after the channel has been opened.

• 200:  nsViewSourceChannel::Open(nsIInputStream **_retval)
• 204:   nsresult rv = mChannel->Open(_retval);
• 206:   mOpened = PR_TRUE;
• 213:  nsViewSourceChannel::AsyncOpen(nsIStreamListener *aListener, nsISupports *ctxt)
• 220:   * We want to add ourselves to the loadgroup before opening
• 231:   nsresult rv = mChannel->AsyncOpen(this, ctxt);
• 239:   mOpened = PR_TRUE;
• 347:   if (!mOpened) {

• 75:   , mOpened(PR_FALSE) {}
• 88:   PRBool mOpened;

• 54:  nsDataChannel::OpenContentStream(PRBool async, nsIInputStream **result,

• 55:   virtual nsresult OpenContentStream(PRBool async, nsIInputStream **result,

• 152:   OpenCacheEntry(uri, getter_AddRefs(descriptor));
• 191:  nsAboutCacheEntry::OpenCacheEntry(nsIURI *uri, nsICacheEntryDescriptor **result)
• 214:   rv = session->OpenCacheEntry(key, nsICache::ACCESS_READ, PR_FALSE, result);
• 387:   descriptor->OpenInputStream(0, getter_AddRefs(stream));

• 107:   // about: modules... Since those URIs will never open a channel, might as

• 143:   rv = lfile->OpenANSIFileDesc("w", &out);

• 72:   nsresult OpenCacheEntry(nsIURI *, nsICacheEntryDescriptor **);

• 90:   nsresult OpenSocket(nsIEventTarget *target);
• 185:   rv = OpenSocket(CallbackTarget());
• 195:  nsGopherContentStream::OpenSocket(nsIEventTarget *target)
• 199:   // We begin by opening a socket to the specified host and wait for the
• 229:   rv = mSocket->OpenOutputStream(0, 0, GOPHER_MAX_WRITE_SEGMENT_COUNT,
• 247:   // Open input stream
• 249:   rv = mSocket->OpenInputStream(0, 0, 0, getter_AddRefs(input));
• 473:  nsGopherChannel::OpenContentStream(PRBool async, nsIInputStream **result,
• 476:   // Implement nsIChannel::Open in terms of nsIChannel::AsyncOpen

• 62:   virtual nsresult OpenContentStream(PRBool async, nsIInputStream **result,

• 1104:   // open cache entry for writing, and configure it to receive data.
• 1458:   // therefore, we can open an unbuffered socket output stream.
• 1460:   rv = mDataTransport->OpenOutputStream(nsITransport::OPEN_UNBUFFERED,
• 1500:   // open a buffered, asynchronous socket input stream
• 1502:   rv = mDataTransport->OpenInputStream(0,
• 1592:   mCacheEntry->OpenOutputStream(0, getter_AddRefs(out));
• 1607:  nsFtpState::OpenCacheDataStream()
• 1613:   mCacheEntry->OpenInputStream(0, getter_AddRefs(input));
• 1628:   // Open a non-blocking, buffered input stream...
• 1630:   transport->OpenInputStream(0, FTP_DATA_CHANNEL_SEG_SIZE,
• 2148:   if (NS_FAILED(OpenCacheDataStream()))
• 2207:   // Try to open a cache entry immediately, but if the cache entry is busy,
• 2210:   session->OpenCacheEntry(key, accessReq, PR_FALSE,
• 2217:   nsresult rv = session->AsyncOpenCacheEntry(key, accessReq, this);

• 120:   virtual nsresult OpenContentStream(PRBool async, nsIInputStream **result,

• 146:  nsFtpChannel::OpenContentStream(PRBool async, nsIInputStream **result,

• 195:   * AsyncOpen implementation.
• 200:   * This method opens a cache entry for reading or writing depending on the
• 201:   * state of the channel and of the system (e.g., opened for reading if we
• 220:   * mCacheEntry is non-null and opened with read access.
• 227:   * method assumes that mCacheEntry is non-null and opened with read access.
• 229:   nsresult OpenCacheDataStream();
• 235:   * assumes that mCacheEntry is non-null and opened with write access.

• 145:   // open buffered, blocking output stream to socket. so long as commands
• 148:   rv = mSocket->OpenOutputStream(nsITransport::OPEN_BLOCKING, 1024, 1,
• 153:   // open buffered, non-blocking/asynchronous input stream to socket.
• 155:   rv = mSocket->OpenInputStream(0,

• 59:   PRFileDesc* udpFD = PR_OpenUDPSocket(aFamily);

• 90:   sock = PR_OpenTCPSocket(family);

• 56:  typedef int (*iw_open_t)(void);
• 70:  static iw_open_t iw_open = nsnull;
• 132:   void* iwlib_handle = dlopen("libiw.so", RTLD_NOW);
• 134:   iwlib_handle = dlopen("libiw.so.29", RTLD_NOW);
• 144:   iw_open = (iw_open_t) dlsym(iwlib_handle, "iw_sockets_open");
• 148:   if (!iw_open || !iw_enum || !iw_stats) {
• 154:   int skfd = (*iw_open)();

• 32:  // WlanOpenHandle
• 34:  typedef DWORD (WINAPI *WlanOpenHandleFunction)(DWORD dwClientVersion,

• 166:   FILE_SHARE_READ, NULL, OPEN_EXISTING,
• 216:   OPEN_EXISTING,
• 266:   if (RegOpenKeyExW(HKEY_LOCAL_MACHINE,
• 293:   if (RegOpenKeyExW(network_cards_key,
• 546:   WlanOpenHandleFunction WlanOpenHandle = (WlanOpenHandleFunction) GetProcAddress(wlan_library, "WlanOpenHandle");
• 552:   if (!WlanOpenHandle ||
• 574:   if ((*WlanOpenHandle)(kXpWlanClientVersion,

• 59:   void *apple_80211_library = dlopen(

• 217:   * best list. Typically used for an "open with" style user
• 276:   * through to nsIURILoader.openURI. If this parameter is null or
• 280:   * nsIBrowserDOMWindow.openURI. In the future, it may attempt to

• 438:   if (noErr != FSpOpenRF(&m_fsFileSpec, fsWrPerm, &m_rfRefNum))

• 267:   open must be 0 then.
• 272:   @param attributeHTML (in): HTML-attribute to add to opening tagHTML,
• 275:   @param open (in/out): Number of currently open tags of type tagHTML
• 282:   nsString& aOutputString, PRUint32& openTags);

• 504:   * A block is always 512 bytes on OpenVMS, compute size.
• 507:   * A block is always 512 bytes on OpenVMS, compute size.
• 1765:   else if ((infile = fopen(argv[1], "r")) != ((FILE *)0))
• 1768:   fprintf(stderr, "Unable to open input file '%s'\n", argv[1]);
• 1775:   else if ((outfile = fopen(argv[2], "w")) != ((FILE *)0))
• 1779:   fprintf(stderr, "Unable to open output file '%s'\n", argv[2]);

• 335:   PRBool haveOpeningBracket = PR_FALSE;
• 344:   (aInString[i] == ')' && !haveOpeningBracket) ||
• 354:   haveOpeningBracket = PR_TRUE;
• 684:   nsString& aOutString, PRUint32& openTags)
• 690:   We use the first opening/closing tag, if we can choose */
• 700:   // opening tag
• 704:   (col0 ? LT_IGNORE : LT_DELIMITER), LT_ALPHA) // is opening tag
• 707:   > openTags
• 710:   openTags++;
• 722:   else if (openTags > 0
• 725:   openTags--;
• 1120:   PRUint32 structPhrase_strong = 0; // Number of currently open tags

• 44:  // on the mac and try to open it, stuffit or some other tool is already going to be on the Mac which knows how

• 199:  nsPartChannel::Open(nsIInputStream **result)
• 201:   // This channel cannot be opened!
• 206:  nsPartChannel::AsyncOpen(nsIStreamListener *aListener, nsISupports *aContext)
• 208:   // This channel cannot be opened!

• 72:  // For Windows NT 4, 2000, and XP, we sometimes want to open the RAS dialup
• 77:  // database. If the service is not running, we will open the RAS dialogs

• 114:  nsInputStreamTransport::OpenInputStream(PRUint32 flags,
• 130:   PRBool nonblocking = !(flags & OPEN_BLOCKING);
• 154:  nsInputStreamTransport::OpenOutputStream(PRUint32 flags,
• 160:   NS_NOTREACHED("nsInputStreamTransport::OpenOutputStream");
• 316:  nsOutputStreamTransport::OpenInputStream(PRUint32 flags,
• 322:   NS_NOTREACHED("nsOutputStreamTransport::OpenInputStream");
• 327:  nsOutputStreamTransport::OpenOutputStream(PRUint32 flags,
• 343:   PRBool nonblocking = !(flags & OPEN_BLOCKING);

• 44:  nsInputStreamChannel::OpenContentStream(PRBool async, nsIInputStream **result,

• 197:  nsFileInputStream::Open(nsIFile* aFile, PRInt32 aIOFlags, PRInt32 aPerm)
• 201:   // If the previous file is open, close it
• 207:   // Open the file
• 216:   rv = localFile->OpenNSPRFileDesc(aIOFlags, aPerm, &fd);
• 224:   // opened the file descriptor, we'll try to remove the file. if that
• 228:   if (NS_FAILED(rv) && !(mBehaviorFlags & REOPEN_ON_REWIND)) {
• 229:   // If REOPEN_ON_REWIND is not happenin', we haven't saved the file yet
• 246:   // If the file will be reopened on rewind, save the info to open the file
• 247:   if (mBehaviorFlags & REOPEN_ON_REWIND) {
• 253:   return Open(aFile, aIOFlags, aPerm);
• 266:   // If we don't need to save the file for reopening, free it up
• 267:   if (!(mBehaviorFlags & REOPEN_ON_REWIND)) {
• 345:   if (mBehaviorFlags & REOPEN_ON_REWIND) {
• 346:   nsresult rv = Reopen();
• 395:   rv = localFile->OpenNSPRFileDesc(ioFlags, perm, &fd);

• 107:   * The file being opened. Only stored when DELETE_ON_CLOSE or
• 108:   * REOPEN_ON_REWIND are true.
• 112:   * The IO flags passed to Init() for the file open.
• 113:   * Only set for REOPEN_ON_REWIND.
• 117:   * The permissions passed to Init() for the file open.
• 118:   * Only set for REOPEN_ON_REWIND.
• 128:   * Internal, called to open a file. Parameters are the same as their
• 131:   nsresult Open(nsIFile* file, PRInt32 ioFlags, PRInt32 perm);
• 133:   * Reopen the file (for OPEN_ON_READ only!)
• 135:   nsresult Reopen() { return Open(mFile, mIOFlags, mPerm); }

• 146:   // this method instructs the socket transport to open a socket of the

• 91:   , mWasOpened(PR_FALSE)
• 99:   PRBool openNewChannel)
• 150:   // If we fail to open the new channel, then we want to leave this channel
• 154:   if (openNewChannel) {
• 155:   rv = newChannel->AsyncOpen(mListener, mListenerContext);
• 226:   nsresult rv = OpenContentStream(PR_TRUE, getter_AddRefs(stream),
• 499:  nsBaseChannel::Open(nsIInputStream **result)
• 503:   NS_ENSURE_TRUE(!mWasOpened, NS_ERROR_IN_PROGRESS);
• 506:   nsresult rv = OpenContentStream(PR_FALSE, result, getter_AddRefs(chan));
• 512:   rv = chan->Open(result);
• 514:   return NS_ImplementChannelOpen(this, result);
• 516:   mWasOpened = NS_SUCCEEDED(rv);
• 522:  nsBaseChannel::AsyncOpen(nsIStreamListener *listener, nsISupports *ctxt)
• 526:   NS_ENSURE_TRUE(!mWasOpened, NS_ERROR_ALREADY_OPENED);
• 536:   // Store the listener and context early so that OpenContentStream and the
• 557:   mWasOpened = PR_TRUE;

• 47:  // used to satisfy the nsBaseChannel::OpenContentStream method.

• 120:   tfp = fopen("/tmp/bufstats", "w");

• 75:   // release the sink first since it may still hold an open file

• 83:   nsresult rv = lf->OpenNSPRFileDesc(flags, 0600, &fd);
• 299:   rv = channel->AsyncOpen(this, nsnull);
• 305:   // mChannel and this until we know for a fact that AsyncOpen has succeeded,

• 342:   rv = transport->OpenInputStream(0, mSegSize, mSegCount, getter_AddRefs(wrapper));

• 118:   // OnStopRequest before returning from AsyncOpen, which is totally

• 298:   mFD = PR_OpenTCPSocket(aAddr->raw.family);

• 58:   virtual nsresult OpenContentStream(PRBool async, nsIInputStream **result,

• 313:   if (NS_SUCCEEDED(channel->AsyncOpen(mLoader, nsnull)))

• 194:   LONG result = ::RegOpenKeyExW(
• 203:   LOGE(("Autodial: Error opening reg key Internet Settings"));
• 334:   // If no default connection specified, open the dialup dialog that lets
• 480:   result = ::RegOpenKeyExW(
• 499:   result = ::RegOpenKeyExW(
• 509:   result = ::RegOpenKeyExW(
• 551:   OpenSCManager(nsnull, SERVICES_ACTIVE_DATABASE, SERVICE_QUERY_STATUS);
• 555:   LOGE(("Autodial: failed to open service control manager. Error %d.",
• 562:   OpenServiceW(hSCManager, L"RasAuto", SERVICE_QUERY_STATUS);
• 566:   LOGE(("Autodial: failed to open RasAuto service."));
• 635:   LONG result = ::RegOpenKeyExW(
• 644:   LOGE(("Autodial: Error opening reg key ...CurrentVersion\\Telephony\\Locations"));

• 977:   fd = PR_OpenTCPSocket(mNetAddr.raw.family);
• 1642:  nsSocketTransport::OpenInputStream(PRUint32 flags,
• 1647:   LOG(("nsSocketTransport::OpenInputStream [this=%x flags=%x]\n",
• 1655:   if (!(flags & OPEN_UNBUFFERED) || (flags & OPEN_BLOCKING)) {
• 1657:   //PRBool openBuffered = !(flags & OPEN_UNBUFFERED);
• 1658:   PRBool openBlocking = (flags & OPEN_BLOCKING);
• 1666:   !openBlocking, PR_TRUE, segsize, segcount, segalloc);
• 1679:   // flag input stream as open
• 1690:  nsSocketTransport::OpenOutputStream(PRUint32 flags,
• 1695:   LOG(("nsSocketTransport::OpenOutputStream [this=%x flags=%x]\n",
• 1702:   if (!(flags & OPEN_UNBUFFERED) || (flags & OPEN_BLOCKING)) {
• 1704:   //PRBool openBuffered = !(flags & OPEN_UNBUFFERED);
• 1705:   PRBool openBlocking = (flags & OPEN_BLOCKING);
• 1713:   PR_TRUE, !openBlocking, segsize, segcount, segalloc);
• 1726:   // flag output stream as open
• 1992:   FILE *fp = fopen(path, "a");

• 59:  // implementing the OpenContentStream method, which will be called by the
• 60:  // nsIChannel::AsyncOpen and nsIChannel::Open implementations.
• 97:   // true when called from nsIChannel::AsyncOpen and false otherwise. When
• 105:   // NS_ERROR_NOT_IMPLEMENTED to cause the basechannel to implement Open in
• 106:   // terms of AsyncOpen (see NS_ImplementChannelOpen).
• 111:   virtual nsresult OpenContentStream(PRBool async, nsIInputStream **stream,
• 135:   // observers of this redirect as well as of opening the new channel, if asked
• 138:   // redirect could not be performed (no channel was opened; this channel
• 142:   PRBool openNewChannel);
• 147:   // SetContentType, and should also not be called after OpenContentStream.
• 247:   // returned success from AsyncOpen while posting a redirect runnable.
• 287:   PRPackedBool mWasOpened;

• 212:   nsresult rv = mChannel->AsyncOpen(this, nsnull);

• 70:   * that will be notified when the data has been loaded. Then call asyncOpen()
• 72:   * argument in the asyncOpen() call will be passed to the onStreamComplete()

• 93:   * loaded. Then call asyncOpen() on the channel with the nsIUnicharStreamLoader
• 94:   * as the listener. The context argument in the asyncOpen() call will be

• 51:   * by calling nsIChannel::open or nsIChannel::asyncOpen.
• 124:   * Setting contentType before the channel has been opened provides a hint
• 128:   * Setting contentType after onStartRequest has been fired or after open()
• 131:   * Setting contentType between the time that asyncOpen() is called and the
• 163:   * Synchronously open the channel.
• 172:   * is reopened.
• 174:   nsIInputStream open();
• 177:   * Asynchronously open this channel. Data is fed to the specified stream
• 179:   * called on the thread that calls asyncOpen and are not called until
• 180:   * after asyncOpen returns. If asyncOpen returns successfully, the
• 193:   * If asyncOpen returns successfully, the channel is responsible for
• 200:   * NOTE: Implementations should throw NS_ERROR_ALREADY_OPENED if the
• 201:   * channel is reopened.
• 207:   void asyncOpen(in nsIStreamListener aListener, in nsISupports aContext);
• 233:   * passed to the asyncOpen method of some other channel

• 52:   * and opening a channel on such a sanitize: URI gets the data from

• 62:   * (e.g. nsIChannel implementations are only pending once asyncOpen
• 80:   * Cancels the current request. This will close any open input or
• 105:   * any open streams remain logically opened and will continue delivering
• 119:   * Resumes the current request. This may have the effect of re-opening
• 121:   * any open streams.
• 220:   * to the request when opened. This means that things like authorization

• 90:   * The new channel. This channel is not opened yet.

• 137:   * The transport is in the connected state, and read/write streams can be opened

• 114:   * Returned from nsIChannel::asyncOpen to indicate that OnDataAvailable will
• 127:   * Implementations of nsIChannel::asyncOpen will commonly return this error
• 128:   * if the channel has already been opened (and has not yet been closed).
• 134:   * Returned from nsIChannel::asyncOpen when trying to open the channel again
• 135:   * (reopening is not supported).
• 137:  #define NS_ERROR_ALREADY_OPENED \

• 103:   * nsICacheService::openSession() to access the cache's entries.
• 153:   * The client ID for this application cache. Clients can open a

• 47:   * prior to the invocation of asyncOpen on the channel.

• 220:   * on the listener passed to AsyncOpen and they therefore
• 233:   * URIs for this protocol execute script when they are opened.
• 235:   const unsigned long URI_OPENING_EXECUTES_SCRIPT = (1<<13);

• 214:  NS_OpenURI(nsIInputStream **result,
• 228:   rv = channel->Open(&stream);
• 241:  NS_OpenURI(nsIStreamListener *listener,
• 254:   rv = channel->AsyncOpen(listener, context);
• 561:   rv = channel->AsyncOpen(*result, context);
• 600:   * Implement the nsIChannel::Open(nsIInputStream**) method using the channel's
• 601:   * AsyncOpen method.
• 607:  NS_ImplementChannelOpen(nsIChannel *channel,
• 615:   rv = channel->AsyncOpen(listener, nsnull);
• 932:   rv = inTransport->OpenInputStream(nsITransport::OPEN_BLOCKING,
• 956:   rv = inTransport->OpenOutputStream(nsITransport::OPEN_BLOCKING,
• 1069:   nsresult rv = NS_OpenURI(getter_AddRefs(in), uri, ioService);

• 62:   * NS_ERROR_ALREADY_OPENED will be thrown if set after AsyncOpen()
• 74:   * NS_ERROR_ALREADY_OPENED will be thrown if set after AsyncOpen()

• 55:   * after its asyncOpen method has been called. Notifications will cease once
• 75:   * context passed to nsIChannel::asyncOpen.
• 96:   * context passed to nsIChannel::asyncOpen.

• 51:   * @param ioFlags file open flags listed in prio.h (see
• 52:   * PR_Open documentation) or -1 to open the
• 67:   * If OPEN_ON_READ is defined, and the file was recreated after the first
• 79:   * If this is set, the file will be reopened whenever Seek(0) occurs. If
• 80:   * the file is already open and the seek occurs, it will happen naturally.
• 81:   * (The file will only be reopened if it is closed for some reason.)
• 83:   const long REOPEN_ON_REWIND = 1<<3;
• 94:   * @param ioFlags file open flags listed in prio.h (see
• 95:   * PR_Open documentation) or -1 to open the

• 45:   * asyncOpen or open is called. Calling resumeAt after open or asyncOpen

• 50:   * It provides methods to open blocking or non-blocking, buffered or unbuffered
• 64:   * Open flags.
• 66:   const unsigned long OPEN_BLOCKING = 1<<0;
• 67:   const unsigned long OPEN_UNBUFFERED = 1<<1;
• 70:   * Open an input stream on this transport.
• 74:   * OPEN_BLOCKING
• 86:   * OPEN_UNBUFFERED
• 94:   * if OPEN_UNBUFFERED is not set, then this parameter specifies the
• 97:   * if OPEN_UNBUFFERED is not set, then this parameter specifies the
• 100:   nsIInputStream openInputStream(in unsigned long aFlags,
• 105:   * Open an output stream on this transport.
• 109:   * OPEN_BLOCKING
• 121:   * OPEN_UNBUFFERED
• 129:   * if OPEN_UNBUFFERED is not set, then this parameter specifies the
• 132:   * if OPEN_UNBUFFERED is not set, then this parameter specifies the
• 135:   nsIOutputStream openOutputStream(in unsigned long aFlags,
• 140:   * Close the transport and any open streams.

• 92:   * Open file descriptor of the socket to control.

• 53:   * channel is opened, and it may only be called once.
• 65:   * This attribute must be set before the channel is opened, and it may
• 69:   * has been opened.

• 47:   * NOTE: Connection setup is triggered by opening an input or output stream,
• 92:   * NOTE: this attribute cannot be changed once a stream has been opened.
• 149:   * opening the new stream.

• 113:   * opening the channel.
• 187:   * from the cache to satisfy a call to AsyncOpen. If this attribute is
• 190:   * if the AsyncOpen will actually result in data being streamed.

• 71:   virtual nsresult OpenInputStreamForEntry(nsCacheEntry * entry,
• 76:   virtual nsresult OpenOutputStreamForEntry(nsCacheEntry * entry,
• 114:   nsresult OpenDiskCache();

• 52:   * Open
• 55:  nsDiskCacheBlockFile::Open( nsILocalFile * blockFile, PRUint32 blockSize)
• 61:   // open the file - restricted to user, the data could be confidential
• 62:   nsresult rv = blockFile->OpenNSPRFileDesc(PR_RDWR | PR_CREATE_FILE, 00600, &mFD);
• 63:   if (NS_FAILED(rv)) return rv; // unable to open or create file

• 64:   nsresult Open( nsILocalFile * blockFile, PRUint32 blockSize);

• 391:   * ActiveBindings : return PR_TRUE if any bindings have open descriptors

• 219:   // nsresult Open(nsCacheRequest *request, nsICacheEntryDescriptor ** result);
• 220:   // nsresult AsyncOpen(nsCacheRequest *request);

• 408:   * Open
• 413:   nsresult Open( nsILocalFile * cacheDirectory);
• 491:   nsresult OpenBlockFiles();

• 118:   virtual nsresult OpenInputStreamForEntry(nsCacheEntry * entry,
• 123:   virtual nsresult OpenOutputStreamForEntry(nsCacheEntry * entry,

• 73:   virtual nsresult OpenInputStreamForEntry(nsCacheEntry * entry,
• 78:   virtual nsresult OpenOutputStreamForEntry(nsCacheEntry * entry,

• 64:  nsDiskCacheMap::Open(nsILocalFile * cacheDirectory)
• 80:   // open the file - restricted to user, the data could be confidential
• 81:   rv = localFile->OpenNSPRFileDesc(PR_RDWR | PR_CREATE_FILE, 00600, &mMapFD);
• 155:   rv = OpenBlockFiles();
• 177:   // If cache map file and its block files are still open, close them
• 489:   // if not the last record, shift last record into opening
• 606:  nsDiskCacheMap::OpenBlockFiles()
• 617:   rv = mBlockFile[i].Open(blockFile, blockSize);
• 672:   // open and read the file
• 678:   // open the file - restricted to user, the data could be confidential
• 679:   rv = file->OpenNSPRFileDesc(PR_RDONLY, 00600, &fd);
• 826:   // open the file
• 828:   // open the file - restricted to user, the data could be confidential
• 829:   rv = localFile->OpenNSPRFileDesc(PR_RDWR | PR_TRUNCATE | PR_CREATE_FILE, 00600, &fd);

• 233:  nsMemoryCacheDevice::OpenInputStreamForEntry( nsCacheEntry * entry,
• 262:  nsMemoryCacheDevice::OpenOutputStreamForEntry( nsCacheEntry * entry,

• 1143:   PRBool calledFromOpenCacheEntry,
• 1192:   if (NS_FAILED(rv) && calledFromOpenCacheEntry)
• 1208:  nsCacheService::OpenCacheEntry(nsCacheSession * session,
• 1215:   CACHE_LOG_DEBUG(("Opening entry for session %p, key %s, mode %d, blocking %d\n",
• 1489:   // All requests have been removed, but there may still be open descriptors
• 1710:  nsCacheService::OpenInputStreamForEntry(nsCacheEntry * entry,
• 1718:   return device->OpenInputStreamForEntry(entry, mode, offset, result);
• 1722:  nsCacheService::OpenOutputStreamForEntry(nsCacheEntry * entry,
• 1730:   return device->OpenOutputStreamForEntry(entry, mode, offset, result);
• 1876:   NS_ASSERTION(PR_CLIST_IS_EMPTY(&entry->mDescriptorQ), "shouldn't be here with open descriptors");

• 239:  nsCacheEntryDescriptor::OpenInputStream(PRUint32 offset, nsIInputStream ** result)
• 262:  nsCacheEntryDescriptor::OpenOutputStream(PRUint32 offset, nsIOutputStream ** result)
• 490:   * open while referenced.
• 511:   rv = nsCacheService::OpenInputStreamForEntry(cacheEntry, mode,
• 567:   * - also keeps the cache entry open while referenced.
• 587:   rv = nsCacheService::OpenOutputStreamForEntry(cacheEntry, mode, mStartOffset,

• 342:   NS_ASSERTION(!mOutStream, "output stream still open");
• 343:   NS_ASSERTION(mInStreamCount == 0, "input stream still open");
• 362:   NS_WARNING("already have an output stream open");
• 374:   // open file desc for data
• 375:   rv = OpenCacheFile(PR_RDONLY, &fd);
• 376:   if (NS_FAILED(rv)) return rv; // unable to open file
• 377:   NS_ASSERTION(fd, "cache stream lacking open file.");
• 407:   NS_ASSERTION(!mOutStream, "already have an output stream open");
• 408:   NS_ASSERTION(mInStreamCount == 0, "we already have input streams open");
• 552:  // never have both output and input streams open
• 565:   // we have open input streams already
• 567:   NS_WARNING("Attempting to write to cache entry with open input streams.\n");
• 657:  nsDiskCacheStreamIO::OpenCacheFile(PRIntn flags, PRFileDesc ** fd)
• 670:   rv = mLocalFile->OpenNSPRFileDesc(flags, 00600, fd);
• 671:   if (NS_FAILED(rv)) return rv; // unable to open file
• 726:   rv = OpenCacheFile(PR_RDWR | PR_CREATE_FILE, &mFD);
• 772:   // we need an mFD, we better open it now
• 773:   nsresult rv = OpenCacheFile(PR_RDWR | PR_CREATE_FILE, &mFD);
• 864:   // we need an mFD, we better open it now
• 865:   rv = OpenCacheFile(PR_RDWR | PR_CREATE_FILE, &mFD);
• 898:   // we expect nsCacheEntryDescriptor::TransportWrapper::OpenOutputStream()

• 89:   static nsresult OpenCacheEntry(nsCacheSession * session,
• 110:   static nsresult OpenInputStreamForEntry(nsCacheEntry * entry,
• 115:   static nsresult OpenOutputStreamForEntry(nsCacheEntry * entry,
• 210:   PRBool calledFromOpenCacheEntry,

• 87:  nsCacheSession::OpenCacheEntry(const nsACString & key,
• 93:   rv = nsCacheService::OpenCacheEntry(this,
• 103:  NS_IMETHODIMP nsCacheSession::AsyncOpenCacheEntry(const nsACString & key,
• 108:   rv = nsCacheService::OpenCacheEntry(this,

• 71:   virtual nsresult OpenInputStreamForEntry(nsCacheEntry * entry,
• 76:   virtual nsresult OpenOutputStreamForEntry(nsCacheEntry * entry,

• 94:   nsresult OpenCacheFile(PRIntn flags, PRFileDesc ** fd);

• 979:   rv = ss->OpenDatabase(indexFile, getter_AddRefs(mDB));
• 1438:  nsOfflineCacheDevice::OpenInputStreamForEntry(nsCacheEntry *entry,
• 1443:   LOG(("nsOfflineCacheDevice::OpenInputStreamForEntry [key=%s]\n",
• 1475:  nsOfflineCacheDevice::OpenOutputStreamForEntry(nsCacheEntry *entry,
• 1480:   LOG(("nsOfflineCacheDevice::OpenOutputStreamForEntry [key=%s]\n",

• 373:   // Open Disk Cache
• 374:   rv = OpenDiskCache();
• 649:  nsDiskCacheDevice::OpenInputStreamForEntry(nsCacheEntry * entry,
• 654:   CACHE_LOG_DEBUG(("CACHE: disk OpenInputStreamForEntry [%p %x %u]\n",
• 677:  nsDiskCacheDevice::OpenOutputStreamForEntry(nsCacheEntry * entry,
• 682:   CACHE_LOG_DEBUG(("CACHE: disk OpenOutputStreamForEntry [%p %x %u]\n",
• 747:   * This routine will get called every time an open descriptor is written to.
• 885:  nsDiskCacheDevice::OpenDiskCache()
• 887:   // if we don't have a cache directory, create one and open it
• 895:   // Try opening cache map file.
• 896:   rv = mCacheMap.Open(mCacheDirectory);
• 909:   // if we don't have a cache directory, create one and open it
• 917:   // reopen the cache map
• 918:   rv = mCacheMap.Open(mCacheDirectory);

• 253:   return PR_TRUE; // stay active if we still have open descriptors

• 66:   * by the storage policy will not be searched when opening entries

• 70:   * Open blocking input stream to cache data. This will fail if the cache
• 81:   nsIInputStream openInputStream(in unsigned long offset);
• 84:   * Open blocking output stream to cache data. This will fail if the cache
• 89:   * If opening an output stream to existing cached data, the data will be
• 98:   nsIOutputStream openOutputStream(in unsigned long offset);

• 101:   * then you must open a cache entry requesting WRITE access. Only one
• 113:   * opened to the cache entry.
• 117:   * cache entry descriptor open with WRITE access.
• 120:   * descriptor with WRITE access is currently open, then the existing cache
• 164:   * The synchronous OpenCacheEntry() may be blocking or non-blocking. If a cache entry is
• 166:   * key can be created, OpenCacheEntry() will return NS_ERROR_CACHE_WAIT_FOR_VALIDATION in

• 63:   * its descriptor, other attempts to open the same cache entry will block.
• 74:   nsICacheEntryDescriptor openCacheEntry(in ACString key,
• 83:   void asyncOpenCacheEntry(in ACString key,

• 131:   * Get the number of times the cache entry has been opened.
• 136:   * Get the last time the cache entry was opened (in seconds since the Epoch).

• 344:   // Compare the family name of the font that's been opened to see

• 694:   dc = DevOpenDC((HAB)1, OD_MEMORY,"*",0L, NULL, NULLHANDLE);

• 55:  #if defined (_SVR4) || defined (SVR4) || defined (__OpenBSD__) || defined (_sgi) || defined (__sun) || defined (sun) || defined (__digital__)

• 90:  /* print-to-file: could not open output file */
• 91:  #define NS_ERROR_GFX_PRINTER_COULD_NOT_OPEN_FILE \

• 81:  // Open tree widget twisty
• 82:  #define NS_THEME_TREEVIEW_TWISTY_OPEN 48
• 159:  // The dropdown button(s) that open up a dropdown list.

• 3:  Copyright 1987, 1998 The Open Group
• 17:  OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
• 21:  Except as contained in this notice, the name of The Open Group shall not be
• 23:  in this Software without prior written authorization from The Open Group.
• 77:  #if defined (_SVR4) || defined (SVR4) || defined (__OpenBSD__) || defined (_sgi) || defined (__sun) || defined (sun) || defined (__digital__)

• 36:  /* A structure representing an open-ended horizontal span of constant
• 38:  typedef struct _cairo_half_open_span {
• 44:  } cairo_half_open_span_t;
• 59:   const cairo_half_open_span_t *coverages,

• 182:   * good as the open-coded solution below, (which is "HACKMEM 169").
• 2198:   const cairo_half_open_span_t *spans,

• 166:  #define popen _popen

• 1063:  struct PatternToPenConverter {
• 1064:   PatternToPenConverter (const cairo_pattern_t *source,
• 1099:   Qt::PenStyle pstyle = Qt::NoPen;
• 1116:   if (pstyle != Qt::NoPen) {
• 1139:   ~PatternToPenConverter() {
• 1359:   PatternToPenConverter pen(source, style);
• 1858:   FILE *fp = fopen(fn, "wb");

• 649:   * PostScript and Font names from a TrueType/OpenType font.
• 657:   * %CAIRO_INT_STATUS_UNSUPPORTED if the font is not TrueType/OpenType

• 195:   /* Open the test file. */
• 196:   tfHandle = fopen(filePath, "r");
• 197:   CHECK(tfHandle != NULL, status, -1, "Unable to open test file\n", done);
• 299:   inProfile = cmsOpenProfileFromFile(filePath, "r");
• 300:   CHECK(inProfile != NULL, status, -1, "unable to open input profile!\n", done);
• 308:   outProfile = cmsOpenProfileFromFile(filePath, "r");
• 309:   CHECK(outProfile != NULL, status, -1, "unable to open input profile!\n", done);
• 412:   /* Open the file in write mode. */
• 413:   tfHandle = fopen(filename, "w");
• 414:   CHECK(tfHandle != NULL, status, -1, "Couldn't Open Test File For Writing",

• 323:   if (aFormatFlags & (gfxUserFontSet::FLAG_FORMAT_OPENTYPE |

• 87:   case GFX_FONT_TYPE_TT_OPENTYPE:
• 91:   case GFX_FONT_TYPE_PS_OPENTYPE:
• 579:   gfxWindowsFontType(isCFF ? GFX_FONT_TYPE_PS_OPENTYPE : GFX_FONT_TYPE_TRUETYPE) /*type*/,
• 731:   gfxWindowsFontType(isCFF ? GFX_FONT_TYPE_PS_OPENTYPE : GFX_FONT_TYPE_TRUETYPE) /*type*/,

• 514:  // TrueType/OpenType table handling code
• 618:   AutoSwap_PRUint16 version; // 0004 = OpenType 1.5
• 1281:  // Embedded OpenType (EOT) handling
• 1297:   PRUint32 fontDataSize; // Length of the OpenType font (FontData) in PRUint8s

• 2133:   // ENUMLOGFONTEXW::elfFullName, which for OpenType fonts seems to be the
• 2134:   // full font name from the name table. For CFF OpenType fonts this is the
• 2292:   // cairo won't know which font to open without a file.
• 2653:   // of the PostScript metric, but in the PostScript table of OpenType
• 2682:   // Use OpenType spec's suggested position for Roman font.

• 356:   nsresult rv = regKey->Open(nsIWindowsRegKey::ROOT_KEY_LOCAL_MACHINE,
• 815:   if (aFormatFlags & (gfxUserFontSet::FLAG_FORMAT_OPENTYPE |

• 58:   DEVOPENSTRUC dop = { 0, 0, 0, 0, 0 };
• 60:   mDC = DevOpenDC(0, OD_MEMORY, (PSZ)"*", 5, (PDEVOPENDATA)&dop, NULLHANDLE);

• 197:   if (aFormatFlags & (gfxUserFontSet::FLAG_FORMAT_OPENTYPE |

• 335:   // given a TrueType/OpenType data file, produce a EOT-format header

• 60:   * and raster), Type 1 fonts, and TrueType/OpenType fonts.
• 63:   * We prefer Type1 fonts over OpenType fonts to avoid falling back to
• 64:   * things like Arial (opentype) when you ask for Helvetica (type1)
• 71:   GFX_FONT_TYPE_PS_OPENTYPE,
• 72:   GFX_FONT_TYPE_TT_OPENTYPE,
• 171:   else if (metrics.ntmFlags & NTM_PS_OPENTYPE)
• 172:   feType = GFX_FONT_TYPE_PS_OPENTYPE;
• 173:   else if (metrics.ntmFlags & NTM_TT_OPENTYPE)
• 174:   feType = GFX_FONT_TYPE_TT_OPENTYPE;
• 193:   mFontType == GFX_FONT_TYPE_PS_OPENTYPE ||
• 194:   mFontType == GFX_FONT_TYPE_TT_OPENTYPE);

• 157:   FLAG_FORMAT_OPENTYPE = 1 << 1,

• 237:   aSurface->DrawString("This is an open Polygon\0",250,200);

• 272:   vfs->SetAppBoolKey(id, nsIGnomeVFSService::APP_KEY_CAN_OPEN_MULTIPLE,
• 320:   // new window open, and we don't want to check again.
• 510:  nsGNOMEShellService::OpenApplication(PRInt32 aApplication)
• 564:  nsGNOMEShellService::OpenApplicationWithURI(nsILocalFile* aApplication, const nsACString& aURI)

• 89:   // checked this session (so that subsequent window opens don't show the
• 130:   // new window open, and we don't want to check again.
• 333:  nsMacShellService::OpenApplication(PRInt32 aApplication)
• 387:   err = ::LSOpenCFURLRef(appURL, NULL);
• 415:  nsMacShellService::OpenApplicationWithURI(nsILocalFile* aApplication, const nsACString& aURI)
• 443:   OSErr err = ::LSOpenFromURLSpec(&launchSpec, NULL);

• 92:  OpenKeyForReading(HKEY aKeyRoot, const nsAString& aKeyName, HKEY* aKey)
• 96:   DWORD res = ::RegOpenKeyExW(aKeyRoot, flatName.get(), 0, KEY_READ, aKey);
• 127:  // shell\open\command (default) REG_SZ <apppath> -requestPending -osint -url "%1"
• 128:  // shell\open\ddeexec (default) REG_SZ "%1",,0,0,,,,
• 129:  // shell\open\ddeexec NoActivateHandler REG_SZ
• 131:  // \Topic (default) REG_SZ WWW_OpenURL
• 139:  // shell\open\command (default) REG_SZ <apppath> -requestPending -osint -url "%1"
• 140:  // shell\open\ddeexec (default) REG_SZ "%1",,0,0,,,,
• 141:  // shell\open\ddeexec NoActivateHandler REG_SZ
• 143:  // \Topic (default) REG_SZ WWW_OpenURL
• 153:  // shell\open\command (default) REG_SZ <apppath> -requestPending -osint -url "%1"
• 154:  // shell\open\ddeexec (default) REG_SZ "%1",,0,0,,,,
• 155:  // shell\open\ddeexec NoActivateHandler REG_SZ
• 157:  // \Topic (default) REG_SZ WWW_OpenURL
• 171:  // shell\open\command (default) REG_SZ <apppath>
• 186:  #define SOP "\\shell\\open\\command"
• 191:  #define VAL_OPEN "\"%APPPATH%\" -requestPending -osint -url \"%1\""
• 201:   // File Extension Class - as of 1.8.1.2 the value for VAL_OPEN is also checked
• 204:   { MAKE_KEY_NAME1(CLS_HTML, SOP), "", VAL_OPEN },
• 207:   { MAKE_KEY_NAME1(CLS_URL, SOP), "", VAL_OPEN },
• 211:   { MAKE_KEY_NAME1("HTTP", SOP), "", VAL_OPEN },
• 213:   { MAKE_KEY_NAME1("HTTPS", SOP), "", VAL_OPEN }
• 245:   // checked this session (so that subsequent window opens don't show the
• 279:   rv = OpenKeyForReading(HKEY_CLASSES_ROOT, key, &theKey);
• 288:   // Close the key we opened.
• 353:   // new window open, and we don't want to check again.
• 535:   // Try to create/open a subkey under HKLM.
• 567:   // Close the key we opened.
• 575:  nsWindowsShellService::OpenApplication(PRInt32 aApplication)
• 593:   // \Client Subkey Name\shell\open\command\
• 594:   // \Client Subkey Name\shell\open\command\(default) = path to exe
• 599:   nsresult rv = OpenKeyForReading(HKEY_CLASSES_ROOT, application, &theKey);
• 611:   // Close the key we opened.
• 614:   // Find the "open" command
• 617:   application.AppendLiteral("\\shell\\open\\command");
• 619:   rv = OpenKeyForReading(HKEY_CLASSES_ROOT, application, &theKey);
• 630:   // Close the key we opened.
• 697:   // Try to create/open a subkey under HKLM.
• 713:   // Close the key we opened.
• 732:   // Close the key we opened.
• 746:   DWORD res = ::RegOpenKeyExW(HKEY_CURRENT_USER, unread.get(), 0,
• 757:   res = ::RegOpenKeyExW(mailKey, PromiseFlatString(subkeyName).get(),
• 762:   // Close the key we opened.
• 773:   // Close the key we opened.
• 779:  nsWindowsShellService::OpenApplicationWithURI(nsILocalFile* aApplication,
• 807:   rv = regKey->Open(nsIWindowsRegKey::ROOT_KEY_CLASSES_ROOT,
• 808:   NS_LITERAL_STRING("feed\\shell\\open\\command"),

• 97:   * Constants identifying applications that can be opened with
• 98:   * openApplication.
• 104:   * Opens the application specified. If more than one application of the
• 108:   void openApplication(in long aApplication);
• 118:   * Opens an application with a specific URI to load.
• 124:   void openApplicationWithURI(in nsILocalFile aApplication, in ACString aURI);

• 503:   NS_FAILED(regKey->Open(nsIWindowsRegKey::ROOT_KEY_CURRENT_USER,
• 581:   "Applications\\iexplore.exe\\shell\\open\\command");
• 582:   if (NS_FAILED(regKey->Open(nsIWindowsRegKey::ROOT_KEY_CLASSES_ROOT,
• 791:   NS_SUCCEEDED(regKey->Open(nsIWindowsRegKey::ROOT_KEY_CURRENT_USER,
• 1415:   NS_SUCCEEDED(regKey->Open(nsIWindowsRegKey::ROOT_KEY_CURRENT_USER,
• 1456:   NS_SUCCEEDED(regKey->Open(nsIWindowsRegKey::ROOT_KEY_CURRENT_USER,
• 1495:   if (NS_SUCCEEDED(regKey->OpenChild(keyName,
• 1680:   PRBool regKeyOpen = PR_FALSE;
• 1703:   // a new keyname? close any previous one and open the new one
• 1705:   if (regKeyOpen) {
• 1707:   regKeyOpen = PR_FALSE;
• 1709:   regKeyOpen = NS_SUCCEEDED(regKey->
• 1710:   Open(nsIWindowsRegKey::ROOT_KEY_CURRENT_USER,
• 1716:   if (regKeyOpen)
• 1759:   if (NS_SUCCEEDED(regKey->Open(nsIWindowsRegKey::ROOT_KEY_LOCAL_MACHINE,
• 1838:   NS_SUCCEEDED(localCookieFile->OpenNSPRFileDesc(PR_RDONLY, 0444, &fd))) {
• 2026:   if (NS_FAILED(regKey->Open(nsIWindowsRegKey::ROOT_KEY_CURRENT_USER,
• 2096:   NS_SUCCEEDED(regKey->Open(nsIWindowsRegKey::ROOT_KEY_CURRENT_USER,
• 2127:   NS_SUCCEEDED(regKey->Open(nsIWindowsRegKey::ROOT_KEY_CURRENT_USER,

• 339:   { CFSTR("OpenNewTabsInFront"), _SPM(BOOL), "browser.tabs.loadInBackground", _SPM(SetBoolInverted), PR_FALSE, -1 },
• 340:   { CFSTR("NSDefaultOpenDir"), _SPM(STRING), "browser.download.dir", _SPM(SetDownloadFolder), PR_FALSE, -1 },
• 341:   { CFSTR("AutoOpenSafeDownloads"), _SPM(BOOL), nsnull, _SPM(SetDownloadHandlers), PR_FALSE, -1 },
• 352:   { CFSTR("WebKitJavaScriptCanOpenWindowsAutomatically"),
• 353:   _SPM(BOOL), "dom.disable_open_during_load", _SPM(SetBoolInverted), PR_FALSE, -1 }
• 504:   // If we're not set to auto-open safe downloads, we need to clear out the

• 92:   // Ensure aRegistryFile exists before open it
• 99:   // Open It
• 108:   if ((errCode = NR_RegOpen(regPath.get(), &reg))) {

• 189:   if (NR_RegOpen(path.get(), &reg))
• 312:   if (NR_RegOpen(path.get(), &reg)) {

• 324:   { nsnull, "Ignore Unrequested Popups", _OPM(BOOL), "dom.disable_open_during_load", _OPM(SetBool), PR_FALSE, { -1 } },
• 647:   mCookieOpen(PR_FALSE), mCurrHandlingInfo(0)
• 733:   if (mCookieOpen)
• 767:   if (mCookieOpen)
• 771:   mCookieOpen = PR_TRUE;
• 906:   mCookieOpen = PR_FALSE;

• 217:   PRBool mCookieOpen;

• 359:   MAKESAMETYPEPREFTRANSFORM("dom.disable_open_during_load", Bool),
• 377:   MAKESAMETYPEPREFTRANSFORM("dom.disable_window_open_feature.status", Bool),

• 127:   // By opening the Migration FE with a supplied bpm, it will automatically
• 139:   return ww->OpenWindow(nsnull,
• 185:   "SOFTWARE\\Classes\\HTTP\\shell\\open\\command");
• 187:   if (NS_FAILED(regKey->Open(nsIWindowsRegKey::ROOT_KEY_LOCAL_MACHINE,
• 203:   // skip an opening quotation mark if present
• 358:   if (NR_RegOpen(path.get(), &reg))

• 136:   * @param aWindow is the browser window to reopen a closed tab in.
• 138:   * @returns a reference to the reopened tab.
• 162:   * @returns the nsIDOMWindow object of the reopened window

• 184:   // to pop back up one level for new items. If we never get an open tag for
• 204:   // new open tag, that means to commit the description to the previous
• 211:   // This is handled in OpenContainer(), which commits previous text if
• 368:   NS_IMETHOD OpenHead() { return NS_OK; }
• 376:   NS_IMETHOD OpenContainer(const nsIParserNode& aNode);
• 510:  BookmarkContentSink::OpenContainer(const nsIParserNode& aNode)
• 797:  // container (tokens since the heading open tag will have been placed in
• 1433:  static const char kItemOpen[] = "<DT><A";
• 1809:   rv = aOutput->Write(kItemOpen, sizeof(kItemOpen)-1, &dummy);
• 1978:   rv = aOutput->Write(kItemOpen, sizeof(kItemOpen)-1, &dummy);
• 2141:   rv = folderNode->SetContainerOpen(PR_TRUE);
• 2363:   rv = mImportChannel->Open(getter_AddRefs(stream));
• 2529:   rv = rootNode->SetContainerOpen(PR_TRUE);

• 283:   * Open a new browser tab, pointing to the specified URI.
• 285:   * The uri to open the browser tab to
• 287:   fuelIBrowserTab open(in nsIURI aURI);
• 291:   * supports: "TabOpen", "TabClose", "TabMove", "TabSelect"

• 168:   * ZIP_OpenArchive
• 170:   * opens the named zip/jar archive and returns a handle that
• 174:   * @param hZip receives handle if archive opened OK
• 177:  PR_PUBLIC_API(PRInt32) ZIP_OpenArchive(const char * zipname, void** hZip)
• 188:   /*--- create and open the archive ---*/
• 193:   PRFileDesc * fd = PR_Open(zipname, PR_RDONLY, 0400);
• 199:   status = zip->OpenArchive(fd);
• 215:   * Tests the integrity of this open zip archive by extracting each
• 218:   * @param hZip handle obtained from ZIP_OpenArchive
• 240:   * @param hZip handle obtained from ZIP_OpenArchive
• 265:   * extracts named file from an opened archive
• 267:   * @param hZip handle obtained from ZIP_OpenArchive
• 293:   PRFileDesc* fOut = PR_Open(outname, ZFILE_CREATE, item->mode);
• 298:   // When STANDALONE is defined, PR_Open ignores its 3d argument.
• 315:   * @param hZip handle obtained from ZIP_OpenArchive
• 519:  // nsZipArchive::OpenArchive
• 521:  nsresult nsZipArchive::OpenArchive(PRFileDesc * fd)
• 590:   // Let us also cleanup the mFiles table for re-use on the next 'open' call
• 803:   PRFileDesc * fIn = PR_Open(path, PR_RDONLY, 0000);

• 46:   * JARCache contains the collection of open jar files.

• 143:   // without even attempting to open it
• 261:  /* void open (in nsIFile aFile, in PRInt32 aIoFlags); */
• 262:  NS_IMETHODIMP nsZipWriter::Open(nsIFile *aFile, PRInt32 aIoFlags)
• 461:   nsresult rv = aChannel->Open(getter_AddRefs(inputStream));
• 932:   rv = aItem->mChannel->AsyncOpen(stream, nsnull);
• 946:   // Open the zip file for reading

• 84:   * Gets or sets the comment associated with the open zip file.
• 86:   * @throws NS_ERROR_NOT_INITIALIZED if no zip file has been opened
• 101:   * Opens a zip file.
• 103:   * @param aFile the zip file to open
• 104:   * @param aIoFlags the open flags for the zip file from prio.h
• 106:   * @throws NS_ERROR_ALREADY_INITIALIZED if a zip file is already open
• 111:   * @throws <other-error> on failure to open zip file (most likely corrupt
• 114:   void open(in nsIFile aFile, in PRInt32 aIoFlags);
• 140:   * @throws NS_ERROR_NOT_INITIALIZED if no zip file has been opened
• 159:   * @throws NS_ERROR_NOT_INITIALIZED if no zip file has been opened
• 170:   * on the queue then the channel will be opened asynchronously, otherwise
• 171:   * the channel must support being opened synchronously.
• 180:   * @throws NS_ERROR_NOT_INITIALIZED if no zip file has been opened
• 198:   * @throws NS_ERROR_NOT_INITIALIZED if no zip file has been opened
• 213:   * @throws NS_ERROR_NOT_INITIALIZED if no zip file has been opened
• 229:   * @throws NS_ERROR_NOT_INITIALIZED if no zip file has been opened
• 237:   * @throws NS_ERROR_NOT_INITIALIZED if no zip file has been opened

• 46:   * that represents an open archive.
• 65:  /* Open and close the archive
• 67:   * If successful OpenArchive returns a handle in the hZip parameter
• 70:  PR_EXTERN(PRInt32) ZIP_OpenArchive( const char * zipname, void** hZip );
• 74:  /* Test the integrity of every item in this open archive

• 102:   // Open for reading
• 180:   // Open for reading

• 150:   rv = mJarReader->Open(mJarFile);
• 357:   rv = NS_OpenURI(mDownloader, nsnull, mJarBaseURI, nsnull,
• 657:  nsJARChannel::Open(nsIInputStream **stream)
• 659:   LOG(("nsJARChannel::Open [this=%x]\n", this));
• 682:  nsJARChannel::AsyncOpen(nsIStreamListener *listener, nsISupports *ctx)
• 684:   LOG(("nsJARChannel::AsyncOpen [this=%x]\n", this));
• 819:   prefs->GetBoolPref("network.jar.open-unsafe-types", &allowUnpack);
• 828:   // Refuse to unpack view-source: jars even if open-unsafe-types is set.

• 151:   /** constructing does not open the archive. See OpenArchive() */
• 158:   * OpenArchive
• 164:   * @param fd File descriptor of file to open
• 167:   nsresult OpenArchive(PRFileDesc* fd);
• 181:   * Closes an open archive.

• 62:  #define PR_Open(a,b,c) fopen((a),(b)) // XXX Ignores mode

• 164:  nsJAR::Open(nsIFile* zipFile)
• 167:   if (mLock) return NS_ERROR_FAILURE; // Already open!
• 176:   PRFileDesc *fd = OpenFile();
• 179:   rv = mZip.OpenArchive(fd);
• 253:   rv = localFile->OpenNSPRFileDesc(PR_WRONLY | PR_CREATE_FILE, item->mode, &fd);
• 345:   // Open jarfile, to get its own filedescriptor for the stream
• 349:   fd = OpenFile();
• 430:  nsJAR::OpenFile()
• 437:   rv = localFile->OpenNSPRFileDesc(PR_RDONLY, 0000, &fd);
• 1139:   rv = zip->Open(zipFile);

• 155:   PRFileDesc* OpenFile();

• 97:   * Opens a zip file for reading.
• 98:   * It is allowed to open with another file,
• 101:   void open(in nsIFile zipFile);
• 189:   * @param zipEntry the name of the entry to open the stream from
• 196:   * is opened, otherwise the contents of the file entry is returned.
• 198:   * @param zipEntry the name of the entry to open the stream from
• 222:   * is created, initialized, and opened (see nsIZipReader::init and
• 223:   * nsIZipReader::open). Otherwise the previously created zip reader is

• 139:  BZ_EXTERN BZFILE* BZ_API(BZ2_bzReadOpen) (
• 167:  BZ_EXTERN BZFILE* BZ_API(BZ2_bzWriteOpen) (
• 238:  BZ_EXTERN BZFILE * BZ_API(BZ2_bzopen) (
• 243:  BZ_EXTERN BZFILE * BZ_API(BZ2_bzdopen) (

• 896:   rv = newChannel->AsyncOpen(static_cast<nsIStreamListener *>(hvc), nsnull);
• 1295:   ("[this=%p] imgLoader::LoadImage -- Calling channel->AsyncOpen()\n", this));
• 1297:   nsresult openRes = newChannel->AsyncOpen(static_cast<nsIStreamListener *>(pl), nsnull);
• 1301:   if (NS_FAILED(openRes)) {
• 1303:   ("[this=%p] imgLoader::LoadImage -- AsyncOpen() failed: 0x%x\n",
• 1304:   this, openRes));
• 1305:   request->CancelAndAbort(openRes);
• 1306:   return openRes;

• 361:   // It's possible for the channel to fail to open after we've set our

• 114:   // only when the channel has failed to open, and so calling Cancel() on it

• 210:  nsIconChannel::Open(nsIInputStream **_retval)
• 239:  NS_IMETHODIMP nsIconChannel::AsyncOpen(nsIStreamListener *aListener, nsISupports *ctxt)

• 172:  nsIconChannel::Open(nsIInputStream **_retval)
• 203:  NS_IMETHODIMP nsIconChannel::AsyncOpen(nsIStreamListener *aListener, nsISupports *ctxt)

• 198:  nsIconChannel::Open(nsIInputStream **_retval)
• 203:  NS_IMETHODIMP nsIconChannel::AsyncOpen(nsIStreamListener *aListener, nsISupports *ctxt)
• 352:   DEVOPENSTRUC dop = {NULL, "DISPLAY", NULL, NULL, NULL, NULL, NULL, NULL, NULL};
• 353:   hdc = DevOpenDC((HAB)0, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&dop, NULLHANDLE);
• 503:   FILE* fp = fopen(pathStr.get(), "wb+");
• 528:  // channel byte is left open & will be filled in by ConvertMaskBitMap();

• 52:  this case, the acknowledgement may be displayed in an opening screen or leading
• 123:   , mGIFOpen(PR_FALSE)
• 293:   if (mGIFOpen)
• 304:   mGIFOpen = PR_TRUE;
• 310:   if (!mGIFOpen)
• 321:   mGIFOpen = PR_FALSE;

• 101:   PRPackedBool mGIFOpen;

• 97:   * already be opened before ths method is called, and there

• 54:   * To enable this mode, you must use @FT_Open_Face, passing an
• 280:   * A structure to be used with @FT_Open_Face to indicate that the user
• 287:   * FT_Open_Args open_args;
• 298:   * // set up FT_Open_Args structure
• 299:   * open_args.flags = FT_OPEN_PATHNAME | FT_OPEN_PARAMS;
• 300:   * open_args.pathname = my_font_pathname;
• 301:   * open_args.num_params = 1;
• 302:   * open_args.params = &parameter; // we use one optional argument
• 304:   * // open the font
• 305:   * error = FT_Open_Face( library, &open_args, index, &face );

• 54:   * FT_Stream_OpenGzip
• 57:   * Open a new stream to parse gzip-compressed font files. This is
• 72:   * The source stream must be opened _before_ calling this function.
• 82:   * automatically handled when calling @FT_New_Face or @FT_Open_Face.
• 84:   * compressed file, the library will try to open a gzipped stream from
• 85:   * it and re-open the face with it.
• 91:   FT_Stream_OpenGzip( FT_Stream stream,

• 46:   * interpreter for a typeface opened by @FT_Open_Face.

• 46:   /* face_index :: The index of the TrueType font, if we are opening a */
• 89:   /* face_index :: The index of the TrueType font, if we are opening a */
• 143:   /* face_index :: The index of the TrueType font, if we are opening a */
• 416:   /* opened). In case of error, all partially allocated tables are */

• 149:   /* You need two opening and closing parentheses! */

• 55:   /* typically implement an LRU cache of opened face objects to reduce */
• 57:   /* global hints every time the same face is re-opened. */
• 60:   /* object, in order to speed up font re-opening time. Of course, this */

• 309:  #define FT_SERVICE_OPENTYPE_VALIDATE_H <freetype/internal/services/svotval.h>

• 89:   * - Open a new hint recording session by calling the `open' method.
• 123:   * T1_Hints_OpenFunc
• 135:   * close an opened recording session.
• 139:   (*T1_Hints_OpenFunc)( T1_Hints hints );
• 322:   * open ::
• 323:   * The function to open a recording session.
• 344:   T1_Hints_OpenFunc open;
• 375:   * - Open a new hint recording session by calling the `open' method.
• 409:   * T2_Hints_OpenFunc
• 421:   * close an opened recording session.
• 425:   (*T2_Hints_OpenFunc)( T2_Hints hints );
• 636:   * open ::
• 637:   * The function to open a recording session.
• 658:   T2_Hints_OpenFunc open;

• 41:   /*** REQUIRED TRUETYPE/OPENTYPE TABLES DEFINITIONS ***/
• 254:   /*** OPTIONAL TRUETYPE/OPENTYPE TABLES DEFINITIONS ***/
• 415:   /* in a TrueType or OpenType font. These are usually found in the */
• 458:   /* in a TrueType or OpenType font. These are usually found in the */
• 558:   /* A TrueType/OpenType subIndexTable as defined in the `EBLC' */
• 929:   /* following formats: TTF, OpenType-TT, and OpenType-CFF. */
• 949:   /* OpenType-CFF class (T2_Face). */
• 1000:   /* Seeks a stream to the start of a given glyph element, and opens a */
• 1092:   /* Read on font opening. */
• 1100:   /* font opening. Note that some maximum */
• 1126:   /* not loaded by the driver on face opening. */
• 1166:   /* TrueType/OpenType fonts. */
• 1170:   /* TrueType/OpenType fonts. */
• 1179:   /* TrueType/OpenType font. */
• 1185:   /* TrueType/OpenType font. */
• 1307:   /* Optional TrueType/OpenType tables */
• 1378:   /* OpenType. */

• 5:  /* The FreeType OpenType validation service (specification). */
• 22:  #include FT_OPENTYPE_VALIDATE_H
• 28:  #define FT_SERVICE_ID_OPENTYPE_VALIDATE "opentype-validate"

• 109:   /* OpenType validation components */

• 332:   FT_Stream_Open( FT_Stream stream,
• 338:   /* create a new (input) stream from an FT_Open_Args structure */
• 341:   const FT_Open_Args* args,
• 351:   FT_Stream_OpenMemory( FT_Stream stream,

• 265:   /* this data when first opened. This field exists only if */
• 664:   /* faces_list :: The list of faces currently opened by this */
• 748:   /* contains a list of its opened faces. */

• 113:   FT_MODERRDEF( OTvalid, 0x800, "OpenType validation module" )

• 5:  /* FreeType API for validating OpenType tables (specification). */
• 24:  /* OpenType specification. */
• 52:   /* OpenType Validation */
• 55:   /* An API to validate OpenType tables. */
• 59:   /* some OpenType tables (BASE, GDEF, GPOS, GSUB, JSTF, MATH). */
• 70:   * A list of bit-field constants used with @FT_OpenType_Validate to
• 71:   * indicate which OpenType tables should be validated.
• 93:   * Validate all OpenType tables (BASE, GDEF, GPOS, GSUB, JSTF, MATH).
• 115:   * FT_OpenType_Validate
• 118:   * Validate various OpenType tables to assure that all offsets and
• 151:   * This function only works with OpenType fonts, returning an error
• 155:   * @FT_OpenType_Free. A NULL value indicates that the table either
• 160:   FT_OpenType_Validate( FT_Face face,
• 173:   * FT_OpenType_Free
• 176:   * Free the buffer allocated by OpenType validator.
• 184:   * @FT_OpenType_Validate.
• 188:   * @FT_OpenType_Validate only.
• 191:   FT_OpenType_Free( FT_Face face,

• 597:   /* by the sfnt, truetype, and opentype drivers. See @FT_Sfnt_Tag for */

• 48:   /* Access the names embedded in TrueType and OpenType files. */
• 51:   /* The TrueType and OpenType specifications allow the inclusion of */
• 93:   /* please refer to the TrueType or OpenType specification. */

• 53:   * FT_Stream_OpenLZW
• 56:   * Open a new stream to parse LZW-compressed font files. This is
• 69:   * The source stream must be opened _before_ calling this function.
• 79:   * automatically handled when calling @FT_New_Face or @FT_Open_Face.
• 81:   * compressed file, the library will try to open a LZW stream from it
• 82:   * and re-open the face with it.
• 88:   FT_Stream_OpenLZW( FT_Stream stream,

• 276:   * the OpenType specification version 1.4 (mid-2001.)
• 819:   /* the following values are from the OpenType spec */
• 835:   /* This is new in OpenType 1.3 */
• 993:   /* According to OpenType specs v.1.3+, setting bit 57 implies that there */

• 102:   * These values determine how the end of opened sub-paths are
• 299:   * opened ::
• 300:   * A boolean. If~1, the outline is treated as an open path instead
• 307:   * If `opened' is~0 (the default), the outline is treated as a closed
• 310:   * If `opened' is~1, the outline is processed as an open path, and the
• 318:   FT_Bool opened );
• 336:   * open ::
• 337:   * A boolean. If~1, the sub-path is treated as an open one.
• 349:   FT_Bool open );
• 369:   * If the subpath was not `opened', this function will `draw' a
• 504:   * When the outline, or a sub-path, is `opened', the stroker merges
• 550:   * When the outline, or a sub-path, is `opened', the stroker merges

• 137:   /* bitmaps in font files according to the OpenType specification. */
• 142:   /* bitmaps in font files according to the OpenType specification. */
• 412:   /* the OpenType specification (in file `ttinst1.doc') how simple */

• 135:   /* FT_Open_Face */
• 136:   /* FT_Open_Args */
• 153:   /* FT_OPEN_MEMORY */
• 154:   /* FT_OPEN_STREAM */
• 155:   /* FT_OPEN_PATHNAME */
• 156:   /* FT_OPEN_DRIVER */
• 157:   /* FT_OPEN_PARAMS */
• 383:   /* Use @FT_New_Face or @FT_Open_Face to create a new face object from */
• 468:   /* @FT_Open_Face), the library looks for a Unicode charmap within */
• 572:   /* CFF, and OpenType/CFF fonts. It is limited to 256 character */
• 577:   /* CFF, and OpenType/CFF fonts. It is limited to 256 character */
• 582:   /* OpenType/CFF fonts. It is limited to 256 character codes. */
• 586:   /* OpenType fonts contain a charmap for this encoding, since older */
• 801:   /* fonts. Some formats (TrueType & OpenType) */
• 989:   /* now, this means TrueType and OpenType. */
• 1004:   /* from the `GPOS' table (as present in some OpenType fonts). */
• 1109:   * font face (true for TrueType, Type~1, Type~42, CID, OpenType/CFF,
• 1125:   * means: TrueType fonts, OpenType fonts, as well as SFNT-based embedded
• 1647:   /* FT_OPEN_XXX */
• 1651:   /* @FT_Open_Args structure. */
• 1654:   /* FT_OPEN_MEMORY :: This is a memory-based stream. */
• 1656:   /* FT_OPEN_STREAM :: Copy the stream from the `stream' field. */
• 1658:   /* FT_OPEN_PATHNAME :: Create a new input stream from a C~path */
• 1661:   /* FT_OPEN_DRIVER :: Use the `driver' field. */
• 1663:   /* FT_OPEN_PARAMS :: Use the `num_params' and `params' fields. */
• 1665:   /* ft_open_memory :: Deprecated; use @FT_OPEN_MEMORY instead. */
• 1667:   /* ft_open_stream :: Deprecated; use @FT_OPEN_STREAM instead. */
• 1669:   /* ft_open_pathname :: Deprecated; use @FT_OPEN_PATHNAME instead. */
• 1671:   /* ft_open_driver :: Deprecated; use @FT_OPEN_DRIVER instead. */
• 1673:   /* ft_open_params :: Deprecated; use @FT_OPEN_PARAMS instead. */
• 1676:   /* The `FT_OPEN_MEMORY', `FT_OPEN_STREAM', and `FT_OPEN_PATHNAME' */
• 1679:  #define FT_OPEN_MEMORY 0x1
• 1680:  #define FT_OPEN_STREAM 0x2
• 1681:  #define FT_OPEN_PATHNAME 0x4
• 1682:  #define FT_OPEN_DRIVER 0x8
• 1683:  #define FT_OPEN_PARAMS 0x10
• 1685:  #define ft_open_memory FT_OPEN_MEMORY /* deprecated */
• 1686:  #define ft_open_stream FT_OPEN_STREAM /* deprecated */
• 1687:  #define ft_open_pathname FT_OPEN_PATHNAME /* deprecated */
• 1688:  #define ft_open_driver FT_OPEN_DRIVER /* deprecated */
• 1689:  #define ft_open_params FT_OPEN_PARAMS /* deprecated */
• 1699:   /* to @FT_Open_Face. */
• 1720:   /* FT_Open_Args */
• 1723:   /* A structure used to indicate how to open a new font file or */
• 1725:   /* for the functions @FT_Open_Face and @FT_Attach_Stream. */
• 1739:   /* driver :: This field is exclusively used by @FT_Open_Face; */
• 1740:   /* it simply specifies the font driver to use to open */
• 1747:   /* opening a new face. */
• 1751:   /* are tested in the following order by @FT_Open_Face: */
• 1753:   /* If the `FT_OPEN_MEMORY' bit is set, assume that this is a */
• 1759:   /* Otherwise, if the `FT_OPEN_STREAM' bit is set, assume that a */
• 1762:   /* Otherwise, if the `FT_OPEN_PATHNAME' bit is set, assume that this */
• 1763:   /* is a normal file and use `pathname' to open it. */
• 1765:   /* If the `FT_OPEN_DRIVER' bit is set, @FT_Open_Face only tries to */
• 1766:   /* open the file with the driver whose handler is in `driver'. */
• 1768:   /* If the `FT_OPEN_PARAMS' bit is set, the parameters given by */
• 1775:   typedef struct FT_Open_Args_
• 1786:   } FT_Open_Args;
• 1795:   /* This function calls @FT_Open_Face to open a font by its pathname. */
• 1809:   /* See @FT_Open_Face for more details. */
• 1827:   /* This function calls @FT_Open_Face to open a font which has been */
• 1844:   /* See @FT_Open_Face for more details. */
• 1863:   /* FT_Open_Face */
• 1867:   /* @FT_Open_Args. */
• 1873:   /* args :: A pointer to an `FT_Open_Args' structure which must */
• 1892:   /* FT_Open_Face can be used to quickly check whether the font */
• 1906:   FT_Open_Face( FT_Library library,
• 1907:   const FT_Open_Args* args,
• 1949:   /* parameters :: A pointer to @FT_Open_Args which must be filled by */
• 1966:   FT_Open_Args* parameters );

• 340:   * definitions, taken from the TrueType and OpenType specifications.
• 353:   * types and API specific to the TrueType (as well as OpenType) format.
• 367:   * SFNT-based font formats (i.e., TrueType and OpenType).
• 587:   * SFNT-based font formats (i.e., TrueType and OpenType).
• 596:   * FT_OPENTYPE_VALIDATE_H
• 600:   * optional FreeType~2 API which validates OpenType tables (BASE, GDEF,
• 604:  #define FT_OPENTYPE_VALIDATE_H <freetype/ftotval.h>

• 58:   /* i/o routines (i.e. malloc/free/fopen/fread/...) */
• 109:  #define ft_fopen fopen

• 125:   /* uses NetBSD's `zopen' to partially uncompress the file on the fly */
• 392:   /* TrueType & OpenType). */
• 401:   /* OpenType file. */
• 416:   /* or OpenType. The name table contains various strings used to */
• 483:   /* when opening the FT_Face. */
• 495:   /* FT_Open_Args open_args; */
• 500:   /* open_args.flags = FT_OPEN_PATHNAME | FT_OPEN_PARAMS; */
• 501:   /* open_args.pathname = my_font_pathname; */
• 502:   /* open_args.num_params = 1; */
• 503:   /* open_args.params = &parameter; */
• 505:   /* error = FT_Open_Face( library, &open_args, index, &face ); */
• 534:   /* while MS says they should not. OpenType defines two bits in the */
• 538:   /* http://partners.adobe.com/asn/developer/opentype/glyf.html */

• 43:   * to limit the number of concurrently opened @FT_Face and @FT_Size
• 242:   /* The manager intentionally limits the total number of opened */
• 287:   /* max_faces :: Maximum number of opened @FT_Face objects managed by */
• 290:   /* max_sizes :: Maximum number of opened @FT_Size objects managed by */

• 37:   * The function @FT_Get_Gasp can be used to query a TrueType or OpenType
• 90:   * Read the `gasp' table from a TrueType or OpenType font file and

• 5:  /* Tags for TrueType and OpenType tables (specification only). */

• 37:   FT_ERRORDEF_( Cannot_Open_Resource, 0x01, \
• 38:   "cannot open resource" )
• 114:   FT_ERRORDEF_( Cannot_Open_Stream, 0x51, \
• 115:   "cannot open stream" )

• 5:  /* TrueType and OpenType embedded bitmap support (specification). */

• 5:  /* TrueType and OpenType embedded BDF properties (specification). */

• 5:  /* Postcript name table processing for TrueType and OpenType fonts */

• 633:   Opens a gzip (.gz) file for reading or writing. The mode parameter
• 634:   is as in fopen ("rb" or "wb") but can also include a compression level
• 639:   gzopen can be used to read a file which is not in gzip format; in this
• 642:   gzopen returns NULL if the file could not be opened or if there was
• 648:   gzdopen() associates a gzFile with the file descriptor fd. File
• 649:   descriptors are obtained from calls like open, dup, creat, pipe or
• 650:   fileno (in the file has been previously opened with fopen).
• 651:   The mode parameter is as in gzopen.
• 653:   file descriptor fd, just like fclose(fdopen(fd), mode) closes the file
• 654:   descriptor fd. If you want to keep fd open, use gzdopen(dup(fd), mode).
• 655:   gzdopen returns NULL if there was insufficient memory to allocate
• 663:   opened for writing.
• 723:   If the file is opened for reading, this function is emulated but can be
• 724:   extremely slow. If the file is opened for writing, only forward seeks are
• 730:   particular if the file is opened for writing and the new starting position

• 96:  # define F_OPEN(name, mode) \
• 97:   ft_fopen((name), (mode), "mbc=60", "ctx=stm", "rfm=fix", "mrs=512")
• 111:  # include <unix.h> /* for fdopen */
• 113:  # ifndef fdopen
• 114:  # define fdopen(fd,mode) NULL /* No fdopen() */
• 128:  # define fdopen(fd,mode) NULL /* No fdopen() */
• 132:  # define fdopen(fd,type) _fdopen(fd,type)
• 142:  #ifndef F_OPEN
• 143:  # define F_OPEN(name, mode) ft_fopen((name), (mode))

• 5:  /* FreeType's OpenType validation module implementation */

• 5:  /* OpenType GPOS table validator (specification). */

• 5:  /* OpenType validation module error codes (specification only). */
• 21:   /* This file is used to define the OpenType validation module error */

• 5:  /* OpenType table validation (specification only). */

• 5:  /* OpenType common tables validation (specification). */

• 44:   cid_face_open( CID_Face face,

• 5:  /* OpenType Glyph Loader (specification). */

• 29:   /* This file is used to define the OpenType validation module error */

• 3:  /* ftzopen.h */
• 7:  /* This optional component relies on NetBSD's zopen(). It should mainly */
• 21:  #ifndef __FT_ZOPEN_H__
• 22:  #define __FT_ZOPEN_H__
• 168:  #endif /* __FT_ZOPEN_H__ */

• 5:  /* High-level OpenType driver interface (specification). */

• 5:  /* OpenType & CFF data/program tables loader (specification). */

• 5:  /* Basic OpenType/CFF type definitions and interface (specification */

• 5:  /* OpenType Glyph Loader (specification). */

• 5:  /* OpenType objects manager (specification). */
• 40:   /* A handle to an OpenType driver object. */
• 53:   /* A handle to an OpenType size object. */
• 69:   /* A handle to an OpenType glyph slot object. */

• 64:   T1_Open_Face( T1_Face face );

• 125:   /* uses NetBSD's `zopen' to partially uncompress the file on the fly */
• 392:   /* TrueType & OpenType). */
• 401:   /* OpenType file. */
• 416:   /* or OpenType. The name table contains various strings used to */
• 483:   /* when opening the FT_Face. */
• 495:   /* FT_Open_Args open_args; */
• 500:   /* open_args.flags = FT_OPEN_PATHNAME | FT_OPEN_PARAMS; */
• 501:   /* open_args.pathname = my_font_pathname; */
• 502:   /* open_args.num_params = 1; */
• 503:   /* open_args.params = &parameter; */
• 505:   /* error = FT_Open_Face( library, &open_args, index, &face ); */
• 534:   /* while MS says they should not. OpenType defines two bits in the */
• 538:   /* http://partners.adobe.com/asn/developer/opentype/glyf.html */

• 32:  //#define FT_USE_CFF // opentype font driver
• 37:  //#define FT_USE_OTV // opentype validator

• 135:   * hReg - handle to opened registry
• 143:   HREG hReg, /* handle to opened registry */
• 149:   * NR_RegOpen - Open a netscape XP registry
• 152:   * filename - registry file to open. NULL or "" opens the standard
• 154:   * hReg - OUT: handle to opened registry
• 159:  VR_INTERFACE(REGERR) NR_RegOpen(
• 160:   const char *filename, /* reg. file to open (NULL == standard registry) */
• 161:   HREG *hReg /* OUT: handle to opened registry */
• 169:   * hReg - handle of open registry to be closed.
• 175:   HREG hReg /* handle of open registry to close */
• 183:   * hReg - handle of open registry to be flushed.
• 188:   HREG hReg /* handle of open registry to flush */
• 193:   * NR_RegIsWritable - Check read/write status of open registry
• 196:   * hReg - handle of open registry to query
• 203:   HREG hReg /* handle of open registry to query */
• 207:   HREG hReg, /* handle of open registry to pack */
• 236:   * hReg - handle of open registry
• 242:   HREG hReg, /* handle of open registry */
• 272:   * hReg - handle of open registry
• 281:   HREG hReg, /* handle of open registry */
• 295:   * hReg - handle of open registry
• 304:   HREG hReg, /* handle of open registry */
• 320:   * hReg - handle of open registry
• 326:   HREG hReg, /* handle of open registry */
• 339:   * hReg - handle of open registry
• 345:   HREG hReg, /* handle of open registry */
• 355:   * hReg - handle of open registry
• 363:   HREG hReg, /* handle of open registry */
• 374:   * hReg - handle of open registry
• 382:   HREG hReg, /* handle of open registry */
• 395:   * hReg - handle of open registry
• 407:   HREG hReg, /* handle of open registry */
• 427:   * hReg - handle of open registry
• 434:   HREG hReg, /* handle of open registry */
• 446:   * hReg - handle of open registry
• 454:   HREG hReg, /* handle of open registry */
• 466:   * hReg - handle of open registry
• 475:   HREG hReg, /* handle of open registry */
• 489:   * hReg - handle of open registry
• 496:   HREG hReg, /* handle of open registry */
• 508:   * hReg - handle of open registry
• 517:   HREG hReg, /* handle of open registry */
• 530:   * hReg - handle of open registry
• 536:   HREG hReg, /* handle of open registry */
• 548:   * hReg - handle of open registry
• 556:   HREG hReg, /* handle of open registry */

• 44:   * the routines mirror fopen(), fclose() et al
• 54:  BufioFile* bufio_Open(const char* name, const char* mode);

• 161:  #define XP_FileOpen(path, mode) mmio_FileOpen((path), mode )
• 180:  #define XP_FileOpen(path, mode) bufio_Open((path), (mode))
• 202:  #define XP_FileOpen(path, mode) PR_Open((path), mode )
• 236:  /*--- file open modes for stdio ---*/
• 254:  /*--- file open modes for NSPR file I/O ---*/
• 309:  extern XP_File vr_fileOpen(const char *name, const char * mode);
• 313:  #define vr_fileOpen PR_Open

• 47:  MmioFile *mmio_FileOpen(char *path, PRIntn flags, PRIntn mode);

• 75:   BOOL open(CThread * aThread);

• 68:   open(this);

• 83:  BOOL CThread::open(CThread * aThread)
• 85:   dbgOut1("CThread::open");

• 287:   result = ::RegOpenKeyEx(HKEY_LOCAL_MACHINE, szKey, 0, KEY_READ, &keyloc);
• 300:   result = ::RegOpenKeyEx(HKEY_LOCAL_MACHINE, szKey, 0, KEY_READ, &keyloc);
• 342:   LONG result = ::RegOpenKeyEx(HKEY_LOCAL_MACHINE, curKey, 0, KEY_READ,
• 374:   if (ERROR_SUCCESS == ::RegOpenKeyEx(baseloc, curKey, 0,
• 459:   if (ERROR_SUCCESS == ::RegOpenKeyEx(HKEY_LOCAL_MACHINE,
• 471:   if (ERROR_SUCCESS == ::RegOpenKeyEx(HKEY_LOCAL_MACHINE,
• 500:   if (ERROR_SUCCESS == ::RegOpenKeyEx(HKEY_LOCAL_MACHINE,
• 512:   if (ERROR_SUCCESS == ::RegOpenKeyEx(HKEY_LOCAL_MACHINE,
• 548:   if (ERROR_SUCCESS != ::RegOpenKeyEx(HKEY_LOCAL_MACHINE, curKey, 0,
• 551:   if (ERROR_SUCCESS != ::RegOpenKeyEx(HKEY_LOCAL_MACHINE, curKey, 0,
• 572:   if (ERROR_SUCCESS == ::RegOpenKeyEx(baseloc, curKey, 0,
• 624:   if (ERROR_SUCCESS != ::RegOpenKeyEx(aKey, subkey, 0, KEY_READ, &baseloc))
• 635:   if (ERROR_SUCCESS == ::RegOpenKeyEx(baseloc, subkey, 0, KEY_QUERY_VALUE,

• 181:   // Array holding all opened stream listeners for this entry

• 521:   pluginRefNum = pluginFile.OpenPluginResource();

• 114:   int f = open(path, O_RDONLY);
• 315:  // Opens the resource fork for the plugin
• 316:  // Also checks if the plugin is a CFBundle and opens gets the correct resource
• 317:  static short OpenPluginResourceFork(nsIFile *pluginFile)
• 326:   short refNum = ::FSpOpenResFile(&spec, fsRdPerm);
• 332:   refNum = CFBundleOpenBundleResourceMap(bundle);
• 339:  short nsPluginFile::OpenPluginResource()
• 341:   return OpenPluginResourceFork(mPlugin);
• 348:   mRefNum = OpenPluginResourceFork(pluginFile);
• 355:   PRBool ResourceOpened()
• 373:   // First open up resource we can use to get plugin info.
• 375:   // Try to open a resource fork.
• 377:   bool resourceOpened = resourceObject.ResourceOpened();
• 403:   if (!info.fName && resourceOpened) {
• 414:   if (!info.fDescription && resourceOpened) {
• 469:   if (!info.fVariantCount && resourceObject.ResourceOpened()) {

• 359:   * which causes a crash when dbus tries to execute them. dlopening libplayback
• 363:   libplayback_handle = dlopen("libplayback-1.so.0", RTLD_NOW);

• 739:   // so we can search for the opening round bracket
• 1440:   return channel->AsyncOpen(converter, container);
• 1604:   // close FD of mFileCacheOutputStream if it's still open
• 1767:   // and call |nsPluginStreamInfo::UseExistingPluginCacheFile()| on opened stream
• 2268:   return NS_OpenURI(cacheListener, nsnull, aURL, nsnull);
• 2894:   // NS_OpenURI()!
• 3245:   // only open the initial stream if it's one that we can handle internally. Otherwise
• 3246:   // |NS_OpenURI| in |InstantiateEmbeddedPlugin| may open up a OS protocal registered helper app
• 3279:   // opening the stream and seeing if the server hands one back
• 4904:   rv = localFile->OpenNSPRFileDesc(PR_WRONLY | PR_CREATE_FILE | PR_TRUNCATE, 0600, &fd);
• 5039:   rv = localFile->OpenNSPRFileDesc(PR_RDONLY, 0444, &fd);
• 5397:   rv = channel->AsyncOpen(listenerPeer, nsnull);
• 5606:   rv = channel->AsyncOpen(listener, nsnull);

• 245:   char * mimeDescription = LoadRCDATAString( hPlug, NS_INFO_FileOpenName);

• 835:   window->PopPopupControlState(openAbused);
• 863:   // clean up open streams
• 1411:   window->PushPopupControlState(aEnabled ? openAllowed : openAbused,

• 79:  #define DEFAULT_X11_PATH "/usr/openwin/lib/"
• 109:   PRDir *fdDir = PR_OpenDir(DEFAULT_X11_PATH);
• 247:   // otherwise it'll decrease performance by calling popen() in SearchForSoname
• 398:   // fail to resolve Xt symbols when trying to do a dlopen
• 399:   // at runtime. Explicitly opening Xt/Xext into the global
• 408:   // Some dlopen() doesn't recover from a failed PR_LD_NOW (bug 223744)

• 108:   // Open the resource fork for the plugin
• 109:   short OpenPluginResource(void);

• 311:   char *mimeDescription = GetKeyValue(verbuf, TEXT("\\StringFileInfo\\040904E4\\FileOpenName"));

• 65:  #elif defined(bsdi) || defined(FREEBSD) || defined(OPENBSD)
• 67:   * BSD/OS, FreeBSD, and OpenBSD ship sys/types.h that define int32_t and
• 85:   * FreeBSD and OpenBSD define uint32_t and bool.

• 248:   char *pFileOpenTemplate;

• 79:   * responsible for opening the channel. It may or may not be already opened

• 81:  RCDATA NS_INFO_FileOpenName{ "MMOS2 video player(*.avi)|",
• 98:  #define NS_INFO_FileOpenName 3

• 108:  RCDATA NP_INFO_FileOpenName{ "MMOS2 video player(*.avi)|",
• 122:  #define NP_INFO_FileOpenName 3

• 103:   * URL transaction initiatied via the nsINetService::Open(...) call.<BR><BR>

• 41:  HKEY openRegistry();

• 43:  // open the registry, create if necessary
• 44:  HKEY openRegistry()
• 57:   HKEY hkey = openRegistry();

• 343:   char *urlToOpen = NULL;
• 370:   urlToOpen = szDefaultPluginFinderURL;
• 373:   urlToOpen = szPageUrlForJVM;
• 376:   szAddress = new char[lstrlen(urlToOpen) + 1];
• 379:   lstrcpy(szAddress, urlToOpen);
• 393:   urlToOpen = szPageUrlForJavaScript;
• 396:   urlToOpen = szPageUrlForJVM;
• 411:   m_szURLString = new char[lstrlen(szPluginFinderCommandBeginning) + lstrlen(urlToOpen) + 10 +
• 417:   szPluginFinderCommandBeginning, urlToOpen,

• 332:   char *urlToOpen = NULL;
• 360:   urlToOpen = szDefaultPluginFinderURL;
• 363:   urlToOpen = szPageUrlForJVM;
• 366:   szAddress = new char[strlen(urlToOpen) + 1];
• 369:   strcpy(szAddress, urlToOpen);
• 383:   urlToOpen = szPageUrlForJavaScript;
• 386:   urlToOpen = szPageUrlForJVM;
• 401:   m_szURLString = new char[strlen(szPluginFinderCommandBeginning) + strlen(urlToOpen) + 10 +
• 407:   szPluginFinderCommandBeginning, urlToOpen,

• 114:  #define PLUGINFINDER_COMMAND_BEGINNING "javascript:window.open(\""

• 41:  #define NP_INFO_FileOpenName 3

• 65:  #define JVM_SMARTUPDATE_URL "http://www.openvms.compaq.com/openvms/products/ips/mozilla_relnotes.html#java"

• 184:  #if defined(__OpenBSD__) || defined(__NetBSD__) || defined(__FreeBSD__)
• 864:  LCMSAPI cmsHPROFILE LCMSEXPORT cmsOpenProfileFromFile(const char *ICCProfile, const char *sAccess);
• 865:  LCMSAPI cmsHPROFILE LCMSEXPORT cmsOpenProfileFromMem(LPVOID MemPtr, DWORD dwSize);

• 67:   PREF_PARSE_UNTIL_OPEN_PAREN,
• 235:   ps->nextstate = PREF_PARSE_UNTIL_OPEN_PAREN;
• 524:   /* function open and close parsing */
• 525:   case PREF_PARSE_UNTIL_OPEN_PAREN:
• 622:   fp = fopen(argv[1], "r");
• 624:   printf("failed to open file\n");

• 69:  static nsresult openPrefFile(nsIFile* aFile);
• 296:   rv = openPrefFile(aFile);
• 329:   rv = openPrefFile(mCurrentFile);
• 451:  static nsresult openPrefFile(nsIFile* aFile)
• 586:   rv2 = openPrefFile(prefFiles[i]);
• 598:   rv2 = openPrefFile(file);
• 672:   , "openvms.js"

• 80:   * Registering as a preference observer can open an object to potential
• 94:   * open window) will not fall into the cyclical reference trap.

• 1477:   * Portable OpenSSH). */

• 350:   * Libpng is OSI Certified Open Source Software. OSI Certified is a
• 351:   * certification mark of the Open Source Initiative.

• 72:   * Open a MAR file for reading.
• 73:   * @param path Specifies the path to the MAR file to open. This path must
• 74:   * be compatible with fopen.
• 77:  MarFile *mar_open(const char *path);
• 80:  MarFile *mar_wopen(const PRUnichar *path);
• 84:   * Close a MAR file that was opened using mar_open.
• 124:   * compatible with fopen.
• 127:   * path must be compatible with fopen.
• 135:   * compatible with fopen.

• 71:  #define gzopen MOZ_Z_gzopen
• 72:  #define gzdopen MOZ_Z_gzdopen

• 1068:  ZEXTERN gzFile ZEXPORT gzopen OF((const char *path, const char *mode));
• 1070:   Opens a gzip (.gz) file for reading or writing. The mode parameter
• 1071:   is as in fopen ("rb" or "wb") but can also include a compression level
• 1077:   gzopen can be used to read a file which is not in gzip format; in this
• 1080:   gzopen returns NULL if the file could not be opened or if there was
• 1085:  ZEXTERN gzFile ZEXPORT gzdopen OF((int fd, const char *mode));
• 1087:   gzdopen() associates a gzFile with the file descriptor fd. File
• 1088:   descriptors are obtained from calls like open, dup, creat, pipe or
• 1089:   fileno (in the file has been previously opened with fopen).
• 1090:   The mode parameter is as in gzopen.
• 1092:   file descriptor fd, just like fclose(fdopen(fd), mode) closes the file
• 1093:   descriptor fd. If you want to keep fd open, use gzdopen(dup(fd), mode).
• 1094:   gzdopen returns NULL if there was insufficient memory to allocate
• 1103:   opened for writing.
• 1190:   If the file is opened for reading, this function is emulated but can be
• 1191:   extremely slow. If the file is opened for writing, only forward seeks are
• 1197:   particular if the file is opened for writing and the new starting position

• 110:  # define F_OPEN(name, mode) \
• 111:   fopen((name), (mode), "mbc=60", "ctx=stm", "rfm=fix", "mrs=512")
• 128:  # include <unix.h> /* for fdopen */
• 130:  # ifndef fdopen
• 131:  # define fdopen(fd,mode) NULL /* No fdopen() */
• 151:  # define fdopen(fd,mode) NULL /* No fdopen() */
• 156:  # define fdopen(fd,mode) NULL /* No fdopen() */
• 162:  # define fdopen(fd,type) _fdopen(fd,type)
• 172:  #ifndef F_OPEN
• 173:  # define F_OPEN(name, mode) fopen((name), (mode))

• 677:   I think we should always display an open lock icon, if the top level frameset is insecure.
• 1369:   no open

• 232:   NS_OpenURI(mListener, nsnull, uri);
• 3223:  PSMContentListener::OnStartURIOpen(nsIURI *aURI, PRBool *aAbortOpen)
• 3226:   //*aAbortOpen

• 1124:   rv = aFile->OpenNSPRFileDesc(PR_RDONLY, 0, &fd);
• 1133:   if (PR_SUCCESS != PR_GetOpenFileInfo(fd, &file_info))

• 149:   gMyLogFile = PR_Open(MAC_LOG_FILE, PR_WRONLY | PR_CREATE_FILE | PR_APPEND,
• 2132:   PRFileDesc* sock = PR_OpenTCPSocket(family);

• 123:   static SECStatus PR_CALLBACK digest_open(void *, PRBool);

• 166:   rv = hchan->AsyncOpen(mListener->mLoader, nsnull);

• 76:   PRBool open; /* toggle open state for thread */
• 295:   if (mTreeArray[i].open) {
• 336:   nc = (mTreeArray[i].open) ? mTreeArray[i].numChildren : 0;
• 349:   if (mTreeArray[i].open)
• 763:   mTreeArray[i].open = PR_TRUE;
• 812:   nc = (mTreeArray[i].open) ? mTreeArray[i].numChildren : 0;
• 876:   if (mTreeArray[i].open)
• 937:   if (mTreeArray[i].open) {
• 1004:  /* boolean isContainerOpen (in long index); */
• 1006:  nsCertTree::IsContainerOpen(PRInt32 index, PRBool *_retval)
• 1011:   if (el && el->open) {
• 1043:   if (mTreeArray[i].open) {
• 1065:   if (mTreeArray[i].open) {
• 1321:  /* void toggleOpenState (in long index); */
• 1323:  nsCertTree::ToggleOpenState(PRInt32 index)
• 1329:   el->open = !el->open;
• 1330:   PRInt32 newChildren = (el->open) ? el->numChildren : -el->numChildren;
• 1420:   PR_LOG(gPIPNSSLog, PR_LOG_DEBUG, ("OPEN[%d]", mTreeArray[i].open));

• 377:   NS_ERROR("failed to open cert_warn_settings.txt for writing");

• 218:   digest_open, digest_close,
• 344:  // open output file as nsIFileStream object?
• 473:   rv = file->OpenNSPRFileDesc(PR_RDWR|PR_CREATE_FILE|PR_TRUNCATE, 0664,
• 646:  // digest_open
• 649:  nsPKCS12Blob::digest_open(void *arg, PRBool reading)
• 709:   // iterator object must exist when digest has been opened in read mode

• 193:   PR_LOG(gPIPNSSLog, PR_LOG_DEBUG, ("canceling all open SSL sockets to disallow future IO\n"));

• 50:   * where open/close state of nodes must be remembered.

• 57:   * @param targetSite The Site name that was used to open the current connection.

• 66:   * where open/close state of nodes must be remembered.

• 54:   * @param targetSite The Site name that was used to open the current connection.

• 127:   rv = nsNSSDialogHelper::openDialog(parent,
• 159:   // open up the window
• 160:   rv = nsNSSDialogHelper::openDialog(parent,
• 190:   rv = nsNSSDialogHelper::openDialog(nsnull,
• 218:   rv = nsNSSDialogHelper::openDialog(parent,
• 261:   rv = nsNSSDialogHelper::openDialog(parent,
• 308:   rv = nsNSSDialogHelper::openDialog(nsnull,
• 373:   rv = nsNSSDialogHelper::openDialog(nsnull,
• 403:   // open up the window
• 404:   rv = nsNSSDialogHelper::openDialog(parent,
• 437:   // open up the window
• 438:   rv = nsNSSDialogHelper::openDialog(parent,
• 478:   rv = nsNSSDialogHelper::openDialog(parent,
• 492:   rv = nsNSSDialogHelper::openDialog(parent,
• 522:   rv = nsNSSDialogHelper::openDialog(nsnull,
• 558:   rv = nsNSSDialogHelper::openDialog(nsnull,
• 606:   rv = windowWatcher->OpenWindow(parent,
• 653:   rv = nsNSSDialogHelper::openDialog(nsnull,

• 44:   * Common class that uses the window watcher service to open a
• 52:   const static char *kDefaultOpenWindowParam;
• 55:   static nsresult openDialog(

• 49:  const char* nsNSSDialogHelper::kDefaultOpenWindowParam = "centerscreen,chrome,modal,titlebar";
• 52:  nsNSSDialogHelper::openDialog(
• 75:   rv = windowWatcher->OpenWindow(parent,
• 78:   nsNSSDialogHelper::kDefaultOpenWindowParam,

• 97:   rv = nsNSSDialogHelper::openDialog(parent,

• 247:  /* boolean isContainerOpen (in long index); */
• 249:  nsNSSASN1Tree::IsContainerOpen(PRInt32 index, PRBool *_retval)
• 348:  /* void toggleOpenState (in long index); */
• 350:  nsNSSASN1Tree::ToggleOpenState(PRInt32 index)

• 120:  extern FILE *popen(const char *, const char *);

• 4:  Copyright (c) 1993, 1994, 1998 The Open Group.
• 18:  OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
• 22:  Except as contained in this notice, the name of The Open Group shall not be
• 24:  in this Software without prior written authorization from The Open Group.

• 238:  #if defined(__386BSD__) || defined(__NetBSD__) || defined(__FreeBSD__) || defined(__OpenBSD__)
• 276:  #if defined(__386BSD__) || defined(__NetBSD__) || defined(__FreeBSD__) || defined(__OpenBSD__) || defined(MACH)
• 725:  #ifdef __OpenBSD__
• 726:   {"__OpenBSD__", "1"},

• 43:  #define PK12UERR_CERTDB_OPEN 8
• 44:  #define PK12UERR_KEYDB_OPEN 9

• 57:   PK11_INSTALL_OPEN_SCRIPT_FILE,

• 1:  #define OPENBRACE 257

• 1068:  ZEXTERN gzFile ZEXPORT gzopen OF((const char *path, const char *mode));
• 1070:   Opens a gzip (.gz) file for reading or writing. The mode parameter
• 1071:   is as in fopen ("rb" or "wb") but can also include a compression level
• 1077:   gzopen can be used to read a file which is not in gzip format; in this
• 1080:   gzopen returns NULL if the file could not be opened or if there was
• 1085:  ZEXTERN gzFile ZEXPORT gzdopen OF((int fd, const char *mode));
• 1087:   gzdopen() associates a gzFile with the file descriptor fd. File
• 1088:   descriptors are obtained from calls like open, dup, creat, pipe or
• 1089:   fileno (in the file has been previously opened with fopen).
• 1090:   The mode parameter is as in gzopen.
• 1092:   file descriptor fd, just like fclose(fdopen(fd), mode) closes the file
• 1093:   descriptor fd. If you want to keep fd open, use gzdopen(dup(fd), mode).
• 1094:   gzdopen returns NULL if there was insufficient memory to allocate
• 1103:   opened for writing.
• 1190:   If the file is opened for reading, this function is emulated but can be
• 1191:   extremely slow. If the file is opened for writing, only forward seeks are
• 1197:   particular if the file is opened for writing and the new starting position

• 110:  # define F_OPEN(name, mode) \
• 111:   fopen((name), (mode), "mbc=60", "ctx=stm", "rfm=fix", "mrs=512")
• 128:  # include <unix.h> /* for fdopen */
• 130:  # ifndef fdopen
• 131:  # define fdopen(fd,mode) NULL /* No fdopen() */
• 151:  # define fdopen(fd,mode) NULL /* No fdopen() */
• 156:  # define fdopen(fd,mode) NULL /* No fdopen() */
• 162:  # define fdopen(fd,type) _fdopen(fd,type)
• 172:  #ifndef F_OPEN
• 173:  # define F_OPEN(name, mode) fopen((name), (mode))

• 102:  CERTCertDBHandle *OpenCertDB (PRBool readOnly);

• 76:  /* Open a new ZIP file. Takes the name of the zip file and an optional
• 80:  ZIPfile* JzipOpen(char *filename, char *comment);
• 85:   * returned from a previous call to JzipOpen.

• 51:  ER2( PR_DIRECTORY_OPEN_ERROR, "The directory could not be opened." )
• 71:  ER2( PR_PROC_DESC_TABLE_FULL_ERROR, "Process open FD table is full." )
• 72:  ER2( PR_SYS_DESC_TABLE_FULL_ERROR, "System open FD table is full." )

• 81:   * NSSCKFWC_OpenSession
• 296:   * NSSCKFWC_OpenSession
• 300:  NSSCKFWC_OpenSession

• 664:   * may be opened on this token. This routine is optional;
• 677:   * sesisons that may be opened on this token. This routine
• 814:   NSSCKMDSession *(PR_CALLBACK *OpenSession)(
• 877:   * is created by NSSCKMDToken->OpenSession, and may be obtained

• 634:   * nssCKFWToken_OpenSession
• 961:   * nssCKFWToken_OpenSession
• 965:  nssCKFWToken_OpenSession

• 170:  nss_dbm_db_open

• 70:  ** Each open sqlite database is represented by an instance of the
• 104:  ** returned from sqlite3_open() and the corresponding database will by closed.
• 109:  ** database connection remains open.
• 159:   sqlite3*, /* An open database */
• 184:  #define SQLITE_CANTOPEN 14 /* Unable to open the database file */
• 196:  #define SQLITE_NOTADB 26 /* File opened that is not a database file */
• 280:  ** was opened. This includes UPDATE, INSERT and DELETE statements executed
• 326:  ** whenever an attempt is made to open a database table that is
• 337:  ** tries to open the table again and the cycle repeats.
• 419:   sqlite3*, /* An open database */
• 616:  ** Open the sqlite database file "filename". The "filename" is UTF-8
• 617:  ** encoded for sqlite3_open() and UTF-16 encoded in the native byte order
• 618:  ** for sqlite3_open16(). An sqlite3* handle is returned in *ppDb, even
• 619:  ** if an error occurs. If the database is opened (or created) successfully,
• 625:  ** The encoding for the database is UTF-8 if sqlite3_open() is called and
• 626:  ** UTF-16 if sqlite3_open16 is used.
• 628:  ** Whether or not an error occurs when it is opened, resources associated
• 632:  int sqlite3_open(
• 636:  int sqlite3_open16(
• 908:  ** SQLITE_BUSY means that the database engine attempted to open
• 910:  ** Call sqlite3_step() again to retry the open.
• 1317:  ** called right after sqlite3_open().
• 1328:  ** Change the key on an open database. If the current database is not
• 1378:  ** Once sqlite3_open() has been called, changing this variable will invalidate
• 1607:  ** So as not to open security holes in older applications that are
• 1622:  ** whenever a new database connection is opened.
• 1689:   int (*xOpen)(sqlite3_vtab *pVTab, sqlite3_vtab_cursor **ppCursor);
• 1826:  ** xOpen method of the module. Each module implementation will define

• 404:   * open between multiple calls to JAR_verify_extract.

• 43:  extern CERTCertDBHandle *JAR_open_database (void);
• 49:  extern void *jar_open_key_database (void);
• 60:  /* Translate fopen mode arg to PR_Open flags and mode */
• 62:  JAR_FOPEN_to_PR_Open(const char *name, const char *mode);
• 77:  #define JAR_FOPEN(fn,mode) JAR_FOPEN_to_PR_Open(fn,mode)

• 705:  PR_PUBLIC_API(extern gzFile) gzopen (const char *path, const char *mode);
• 707:  extern gzFile EXPORT gzopen OF((const char *path, const char *mode));
• 710:   Opens a gzip (.gz) file for reading or writing. The mode parameter
• 711:   is as in fopen ("rb" or "wb") but can also include a compression level
• 712:   ("wb9"). gzopen can be used to read a file which is not in gzip format;
• 714:   gzopen returns NULL if the file could not be opened or if there was
• 721:  PR_PUBLIC_API(extern gzFile) gzdopen (int fd, const char *mode);
• 723:  extern gzFile EXPORT gzdopen OF((int fd, const char *mode));
• 726:   gzdopen() associates a gzFile with the file descriptor fd. File
• 727:   descriptors are obtained from calls like open, dup, creat, pipe or
• 728:   fileno (in the file has been previously opened with fopen).
• 729:   The mode parameter is as in gzopen.
• 731:   file descriptor fd, just like fclose(fdopen(fd), mode) closes the file
• 732:   descriptor fd. If you want to keep fd open, use gzdopen(dup(fd), mode).
• 733:   gzdopen returns NULL if there was insufficient memory to allocate

• 405:  ** Open the certificate database. Use callback to get name of database.
• 407:  extern SECStatus CERT_OpenCertDB(CERTCertDBHandle *handle, PRBool readOnly,
• 410:  /* Open the certificate database. Use given filename for database. */
• 411:  extern SECStatus CERT_OpenCertDBFilename(CERTCertDBHandle *handle,
• 415:  ** Open and initialize a cert database that is entirely in memory. This
• 416:  ** can be used when the permanent database can not be opened or created.
• 418:  extern SECStatus CERT_OpenVolatileCertDB(CERTCertDBHandle *handle);

• 805:  /* This is the typedef for the callback passed to CERT_OpenCertDB() */

• 108:   * SEC_HttpRequest_TrySendAndReceiveFcn should reopen the connection

• 80:   PRBool defRWSession; /* is the default session RW (we open our default

• 189:   * Open a new database using the softoken. The caller is responsible for making
• 199:   * SECMOD_OpenUserDB().
• 226:   * readOnly - Databases should be opened read only.
• 227:   * noCertDB - Don't try to open a certificate database.
• 228:   * noKeyDB - Don't try to open a key database.
• 229:   * forceOpen - Don't fail to initialize the token if the
• 230:   * databases could not be opened.
• 237:  PK11SlotInfo *SECMOD_OpenUserDB(const char *moduleSpec);

• 187:   CK_ULONG ulMaxSessionCount; /* max open sessions */
• 188:   CK_ULONG ulSessionCount; /* sess. now open */
• 190:   CK_ULONG ulRwSessionCount; /* R/W sess. now open */
• 1166:   CK_VOID_PTR pApplication /* passed to C_OpenSession */

• 192:  /* C_OpenSession opens a session between an application and a
• 194:  CK_PKCS11_FUNCTION_INFO(C_OpenSession)

• 80:  #define PR_Open PR_Open_stub

• 118:  PKIX_ERRORENTRY(CANNOTOPENCOLLECTIONCERTSTORECONTEXTDIRECTORY,Cannot open CollectionCertStoreContext directory,0),
• 550:  PKIX_ERRORENTRY(FORWARDBUILDERSTATEISIOPENDINGFAILED,pkix_ForwardBuilderState_IsIOPending failed,0),
• 1058:  PKIX_ERRORENTRY(UNABLETOOPENCERTFILE,Unable to open cert file,0),
• 1059:  PKIX_ERRORENTRY(UNABLETOOPENCRLFILE,Unable to open crl file,0),

• 94:   * Open the Cert, Key, and Security Module databases, read only.
• 107:   * Open the Cert, Key, and Security Module databases, read/write.
• 115:   * Open the Cert, Key, and Security Module databases, read/write.
• 130:   * flags - change the open options of NSS_Initialize as follows:
• 131:   * NSS_INIT_READONLY - Open the databases read only.
• 132:   * NSS_INIT_NOCERTDB - Don't open the cert DB and key DB's, just
• 134:   * NSS_INIT_NOMODDB - Don't open the security module DB, just
• 136:   * NSS_INIT_FORCEOPEN - Continue to force initializations even if the
• 137:   * databases cannot be opened.
• 178:  #define NSS_INIT_FORCEOPEN 0x8

• 86:  #elif defined(LINUX) || defined(AIX) || defined(VMS) || defined(BEOS) || defined(BSDI) || (defined(NETBSD) && __NetBSD_Version__ < 500000000) || defined(OPENBSD)

• 69:  extern void nss_MD_unix_map_open_error(int err);
• 70:  extern void nss_MD_unix_map_opendir_error(int err);

• 68:  extern void nss_MD_win32_map_open_error(PRInt32 err);
• 69:  extern void nss_MD_win32_map_opendir_error(PRInt32 err);

• 218:  /* New non-experimental openly spec'ed versions of those cipher suites. */

• 70:  extern void nss_MD_os2_map_open_error(PRInt32 err);
• 71:  extern void nss_MD_os2_map_opendir_error(PRInt32 err);

• 46:  typedef int (PR_CALLBACK * PKCS12OpenFunction)(void *arg);
• 75:  typedef SECStatus (PR_CALLBACK *digestOpenFn)(void *arg, PRBool readData);
• 176:   digestOpenFn dOpen, digestCloseFn dClose,

• 1410:   * However, by specifying this as a URI, this keeps open the

• 89:   * Open design question: should these types be more firmly separated?
• 126:   * open; these modules perform the cryptographic operations, and

• 337:   * when the slot is used to open another directory. Between open and close
• 340:   * - reset. The value of this variable is cleared during an open/close
• 342:   * - preserved. The value of this variable is preserved over open/close
• 545:   PRBool forceOpen;
• 560:   PRBool forceOpen;

• 100:  CK_RV s_open(const char *directory, const char *certPrefix,

• 53:  typedef CK_RV (*LGOpenFunc) (const char *dir, const char *certPrefix,
• 76:  CK_RV sftkdbCall_open(const char *dir, const char *certPrefix,

• 476:  /* These need to be global, leave some open fields so we can 'expand'

• 575:   char openQuote = quote;
• 592:   returnValue = PR_smprintf("%s=%c%s%c",name,openQuote,value,closeQuote);

• 172:  nsslowcert_OpenCertDB(NSSLOWCERTCertDBHandle *handle, PRBool readOnly,
• 174:   NSSLOWCERTDBNameFunc namecb, void *cbarg, PRBool openVolatile);

• 51:   * Handle structure for open certificate databases
• 77:  DB * rdbopen(const char *appName, const char *prefix,
• 80:  DB *dbsopen (const char *dbname , int flags, int mode, DBTYPE type,

• 72:  ** Open a key database.
• 74:  extern NSSLOWKEYDBHandle *nsslowkey_OpenKeyDB(PRBool readOnly,

• 49:   * Handle structure for open key databases
• 57:   char *dbname; /* name of the openned DB */

• 180:  /* This is the typedef for the callback passed to nsslowcert_OpenCertDB() */

• 98:   * readOnly - Boolean: true if the databases are to be openned read only.
• 99:   * nocertdb - Don't open the cert DB and key DB's, just initialize the
• 101:   * nomoddb - Don't open the security module DB, just initialize the
• 103:   * forceOpen - Continue to force initializations even if the databases cannot
• 104:   * be opened.
• 110:   PRBool noKeyDB, PRBool forceOpen, PRBool isFIPS,

• 71:  extern DIR *opendir(const char *);
• 72:  extern DIR *openxdir(const char *, unsigned);

• 105:   rv = service->OpenDatabase(storageFile, getter_AddRefs(mConnection));
• 107:   // delete the db and try opening again
• 110:   rv = service->OpenDatabase(storageFile, getter_AddRefs(mConnection));

• 685:  nsDOMWorkerXHRProxy::MaybeDispatchPrematureAbortEvents(PRBool aFromOpenRequest)
• 700:   if (aFromOpenRequest) {
• 868:  nsDOMWorkerXHRProxy::OpenRequest(const nsACString& aMethod,
• 878:   RUN_PROXIED_FUNCTION(OpenRequest,
• 890:   rv = mXHR->OpenRequest(aMethod, aUrl, aAsync, aUser, aPassword);
• 893:   // Do this after OpenRequest is called so that we will continue to run events
• 894:   // from the old channel if OpenRequest fails. Any events generated by the
• 895:   // OpenRequest method will always run regardless of channel ID.

• 139:   class OpenRequest : public SyncEventCapturingRunnable
• 142:   OpenRequest(const nsACString& aMethod, const nsACString& aUrl,
• 149:   return mXHR->OpenRequest(mMethod, mUrl, mAsync, mUser, mPassword);

• 602:  nsDOMWorkerXHR::OpenRequest(const nsACString& aMethod,
• 614:   nsresult rv = mXHRProxy->OpenRequest(aMethod, aUrl, aAsync, aUser, aPassword);
• 621:  nsDOMWorkerXHR::Open(const nsACString& aMethod,
• 690:   return OpenRequest(aMethod, aUrl, async, user, password);

• 95:   nsresult OpenRequest(const nsACString& aMethod,
• 159:   nsresult MaybeDispatchPrematureAbortEvents(PRBool aFromOpenRequest);

• 101:  // loading scripts, etc.) we open another slot in the thread pool for another
• 552:   // Since we're going to block this thread we should open up a new thread

• 341:   // Cancel any async channels that were already opened.
• 511:   rv = loadInfo.channel->AsyncOpen(loader, indexSupports);

• 426:   nsCOMPtr<nsISupports> mContext; // The context passed to AsyncOpen
• 429:   // If we blocked onload on a document in AsyncOpen, this is the document we
• 436:   nsLoadFlags mActualLoadFlags; // See AsyncOpen
• 443:   PRPackedBool mOpenedStreamChannel;
• 450:   mPopupState(openOverridden),
• 454:   mOpenedStreamChannel(PR_FALSE)
• 489:   // Remember, until AsyncOpen is called, the script will not be evaluated
• 542:   if (NS_SUCCEEDED(mStatus) && mOpenedStreamChannel) {
• 556:   if (mOpenedStreamChannel) {
• 598:  nsJSChannel::Open(nsIInputStream **aResult)
• 605:   return mStreamChannel->Open(aResult);
• 609:  nsJSChannel::AsyncOpen(nsIStreamListener *aListener, nsISupports *aContext)
• 684:   if (mOpenedStreamChannel) {
• 703:   // We're returning success from asyncOpen(), but we didn't open a
• 809:   mStatus = mStreamChannel->AsyncOpen(this, mContext);
• 813:   mOpenedStreamChannel = PR_TRUE;
• 1174:   URI_LOADABLE_BY_ANYONE | URI_NON_PERSISTABLE | URI_OPENING_EXECUTES_SCRIPT;

• 48:  typedef HANDLE (*OpenDeviceProc)(HANDLE hNewLocationData, HANDLE hDeviceStateChange, const WCHAR *szDeviceName, DWORD dwFlags);
• 76:   OpenDeviceProc mOpenDevice;

• 234:   mOpenDevice = (OpenDeviceProc) GetProcAddress(mGPSInst,"GPSOpenDevice");
• 239:   if (!mOpenDevice || !mCloseDevice || !mGetPosition || !mGetDeviceState)
• 242:   mGPSDevice = mOpenDevice(NULL, NULL, NULL, 0);

• 46:   attribute boolean open;

• 51:   attribute boolean open;

• 49:   * passed to the code that opened this modal content window.
• 55:   * opened the modal content window.

• 80:   * This is the scriptable version of nsIDOMWindowInternal::open()
• 81:   * that takes 3 optional arguments. Its binary name is OpenJS to
• 82:   * avoid colliding with nsIDOMWindowInternal::open(), which has the
• 89:   [binaryname(OpenJS)] nsIDOMWindow open([optional] in DOMString url,
• 95:   * nsIDOMWindowInternal::openDialog() that takes 3 optional
• 99:   nsIDOMWindow openDialog([optional] in DOMString url,

• 55:   * Values for openURI's aWhere parameter.
• 59:   * and the value of the aContext parameter to openURI.
• 61:   const short OPEN_DEFAULTWINDOW = 0;
• 63:   * Open in the "current window". If aOpener is provided, this should be the
• 64:   * top window in aOpener's window hierarchy, but exact behavior is
• 65:   * application-dependent. If aOpener is not provided, it's up to the
• 68:   const short OPEN_CURRENTWINDOW = 1;
• 70:   * Open in a new window.
• 72:   const short OPEN_NEWWINDOW = 2;
• 74:   * Open in a new content tab in the toplevel browser window corresponding to
• 77:   const short OPEN_NEWTAB = 3;
• 80:   * Values for openURI's aContext parameter. These affect the behavior of
• 81:   * OPEN_DEFAULTWINDOW.
• 86:   const short OPEN_EXTERNAL = 1;
• 88:   * internal open new window
• 90:   const short OPEN_NEW = 2;
• 95:   * @param aURI the URI to open. null is allowed. If null is passed in, no
• 99:   * @param aOpener window requesting the open (can be null).
• 100:   * @param aContext the context in which the URI is being opened. This
• 101:   * is used only when aWhere == OPEN_DEFAULTWINDOW.
• 102:   * @return the window into which the URI was opened.
• 104:   nsIDOMWindow openURI(in nsIURI aURI, in nsIDOMWindow aOpener,
• 110:   * currently open tab in this toplevel browser window.

• 337:   * Get IME open state. TRUE means 'Open', otherwise, 'Close'.
• 340:   readonly attribute boolean IMEIsOpen;

• 90:   attribute nsIDOMWindowInternal opener;
• 148:   * Open a new window with this one as the parent. This method will
• 151:   * name and the default character set on the newly opened window
• 154:   [noscript] nsIDOMWindow open(in DOMString url, in DOMString name,
• 158:   * This method works like open except that aExtraArgument gets
• 165:   [noscript] nsIDOMWindow openDialog(in DOMString url, in DOMString name,

• 70:   // open() is noscript here since the DOM Level 0 version of open()
• 72:   // open() is defined in nsIDOMNSHTMLDocument.
• 73:   [noscript] void open();

• 58:   // This is the internal version of open(); note that the version
• 65:   nsIDOMDocument open(in ACString aContentType,

• 164:   const unsigned long DOM_VK_OPEN_BRACKET = 0xDB;

• 51:   * The window object that attempted to open the blocked popup
• 52:   * (i.e. the window object on which open() was called).
• 63:   * The string of features passed to the window.open() call
• 69:   * The window name passed to the window.open() call

• 771:  nsDOMWindowUtils::GetIMEIsOpen(PRBool *aState)
• 779:   // Open state should not be available when IME is not enabled.
• 786:   return widget->GetIMEOpenState(aState);

• 91:   * the channel's AsyncOpen method is called or whether it should be
• 98:   * Setting this property after asyncOpen has been called on the

• 63:   openAllowed = 0, // open that window without worries
• 64:   openControlled, // it's a popup, but allow it
• 65:   openAbused, // it's a popup. disallow it, but allow domain override.
• 66:   openOverridden // disallow window open
• 251:   // Tell this window who opened it. This only has an effect if there is
• 256:   virtual void SetOpenerScriptPrincipal(nsIPrincipal* aPrincipal) = 0;
• 257:   // Ask this window who opened it.
• 258:   virtual nsIPrincipal* GetOpenerScriptPrincipal() = 0;
• 358:   * Set the opener window. aOriginalOpener is true if and only if this is the
• 359:   * original opener for the window. That is, it can only be true at most once
• 361:   * SetOpenerWindow is called. It might never be true, of course, if the
• 362:   * window does not have an opener when it's created.
• 364:   virtual void SetOpenerWindow(nsIDOMWindowInternal *aOpener,
• 365:   PRBool aOriginalOpener) = 0;
• 371:   * opened/closed with the window as a parent.
• 542:   : mWindow(aWindow), mOldState(openAbused)

• 1114:   // Open the dialog.
• 1192:   // If mOperationCallbackTime got set while the modal dialog was open,
• 3050:  TraceMallocOpenLogFile(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
• 3063:   fd = open(filename, O_CREAT | O_WRONLY | O_TRUNC, 0644);
• 3065:   JS_ReportError(cx, "can't open %s: %s", filename, strerror(errno));
• 3140:   {"TraceMallocOpenLogFile", TraceMallocOpenLogFile, 1, 0, 0},

• 2020:   // when a popup is open, we want to ensure that tab navigation occurs only
• 2021:   // within the most recently opened panel. If a popup is open, its frame will
• 2045:   // remain outside the popup when it is opened.
• 2063:   // if there is no focus, yet a panel is open, focus the first item in

• 215:  static PRInt32 gOpenPopupSpamCount = 0;
• 216:  static PopupControlState gPopupControlState = openAbused;
• 623:   mHadOriginalOpener(PR_FALSE),
• 639:   , mSetOpenerWindowCalled(PR_FALSE)
• 699:   // if this fails to open, Dump() knows to just go to stdout
• 701:   gDumpFile = fopen(fname, "wb+");
• 735:   if (mLastOpenedURI) {
• 736:   mLastOpenedURI->GetSpec(url);
• 861:   mOpener = nsnull; // Forces Release
• 872:   --gOpenPopupSpamCount;
• 1051:   NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NSCOMPTR(mOpenerScriptPrincipal)
• 1092:   NS_IMPL_CYCLE_COLLECTION_UNLINK_NSCOMPTR(mOpenerScriptPrincipal)
• 1312:   // getting called from document.open().
• 1356:  nsGlobalWindow::SetOpenerScriptPrincipal(nsIPrincipal* aPrincipal)
• 1358:   FORWARD_TO_OUTER_VOID(SetOpenerScriptPrincipal, (aPrincipal));
• 1363:   // Do NOT set mOpenerScriptPrincipal in this case, just to be safe.
• 1377:   // Set the opener principal on our document; given the above check, this
• 1382:   mOpenerScriptPrincipal = aPrincipal;
• 1386:  nsGlobalWindow::GetOpenerScriptPrincipal()
• 1388:   FORWARD_TO_OUTER(GetOpenerScriptPrincipal, (), nsnull);
• 1390:   return mOpenerScriptPrincipal;
• 1703:   mLastOpenedURI = aDocument->GetDocumentURI();
• 1864:   // We're called from document.open() (and document.open() is
• 1869:   "How does this opened window get into session history");
• 2229:  nsGlobalWindow::SetOpenerWindow(nsIDOMWindowInternal* aOpener,
• 2230:   PRBool aOriginalOpener)
• 2232:   FORWARD_TO_OUTER_VOID(SetOpenerWindow, (aOpener, aOriginalOpener));
• 2234:   NS_ASSERTION(!aOriginalOpener || !mSetOpenerWindowCalled,
• 2235:   "aOriginalOpener is true, but not first call to "
• 2236:   "SetOpenerWindow!");
• 2237:   NS_ASSERTION(aOpener || !aOriginalOpener,
• 2238:   "Shouldn't set mHadOriginalOpener if aOpener is null");
• 2240:   mOpener = do_GetWeakReference(aOpener);
• 2241:   NS_ASSERTION(mOpener || !aOpener, "Opener must support weak references!");
• 2243:   if (aOriginalOpener) {
• 2244:   mHadOriginalOpener = PR_TRUE;
• 2248:   mSetOpenerWindowCalled = PR_TRUE;
• 2423:   // window.open with an existing window name.
• 2964:  nsGlobalWindow::GetOpener(nsIDOMWindowInternal** aOpener)
• 2966:   FORWARD_TO_OUTER(GetOpener, (aOpener), NS_ERROR_NOT_INITIALIZED);
• 2968:   *aOpener = nsnull;
• 2970:   nsCOMPtr<nsIDOMWindowInternal> opener = do_QueryReferent(mOpener);
• 2971:   if (!opener) {
• 2977:   NS_ADDREF(*aOpener = opener);
• 2981:   // We don't want to reveal the opener if the opener is a mail window,
• 2982:   // because opener can be used to spoof the contents of a message (bug 105050).
• 2983:   // So, we look in the opener's root docshell to see if it's a mail window.
• 2984:   nsCOMPtr<nsPIDOMWindow> openerPwin(do_QueryInterface(opener));
• 2985:   if (openerPwin) {
• 2987:   do_QueryInterface(openerPwin->GetDocShell());
• 2990:   nsCOMPtr<nsIDocShellTreeItem> openerRootItem;
• 2991:   docShellAsItem->GetRootTreeItem(getter_AddRefs(openerRootItem));
• 2992:   nsCOMPtr<nsIDocShell> openerRootDocShell(do_QueryInterface(openerRootItem));
• 2993:   if (openerRootDocShell) {
• 2995:   nsresult rv = openerRootDocShell->GetAppType(&appType);
• 2997:   *aOpener = opener;
• 3002:   NS_IF_ADDREF(*aOpener);
• 3007:  nsGlobalWindow::SetOpener(nsIDOMWindowInternal* aOpener)
• 3010:   // If not, opener is settable only to null.
• 3011:   if (aOpener && !nsContentUtils::IsCallerTrustedForWrite()) {
• 3015:   SetOpenerWindow(aOpener, PR_FALSE);
• 3511:   // if attempting to resize the window, hide any open popups
• 3546:   // if attempting to move the window, hide any open popups
• 4087:   // Reset popup state while opening a modal dialog, and firing events
• 4089:   // the whole time a modal dialog is open.
• 4090:   nsAutoPopupStatePusher popupStatePusher(openAbused, PR_TRUE);
• 4122:   // Reset popup state while opening a modal dialog, and firing events
• 4124:   // the whole time a modal dialog is open.
• 4125:   nsAutoPopupStatePusher popupStatePusher(openAbused, PR_TRUE);
• 4169:   // Reset popup state while opening a modal dialog, and firing events
• 4171:   // the whole time a modal dialog is open.
• 4172:   nsAutoPopupStatePusher popupStatePusher(openAbused, PR_TRUE);
• 4233:   CheckOpenAllow(CheckForAbusePoint()) == allowNoAbuse;
• 4391:   // Firefox lets the user specify multiple home pages to open in
• 4393:   // have the machinery in place to easily open new tabs from here,
• 4932:   * typically abused by web designers. The window.open code uses this
• 4939:   FORWARD_TO_OUTER(CheckForAbusePoint, (), openAbused);
• 4950:   return openAllowed;
• 4956:   // limit the number of simultaneously open popups
• 4957:   if (abuse == openAbused || abuse == openControlled) {
• 4959:   if (popupMax >= 0 && gOpenPopupSpamCount >= popupMax)
• 4960:   abuse = openOverridden;
• 4966:  /* Allow or deny a window open based on whether popups are suppressed.
• 4968:   Returns a value from the CheckOpenAllow enum. */
• 4969:  OpenAllowValue
• 4970:  nsGlobalWindow::CheckOpenAllow(PopupControlState aAbuseLevel)
• 4974:   OpenAllowValue allowWindow = allowNoAbuse; // (also used for openControlled)
• 4976:   if (aAbuseLevel >= openAbused) {
• 4981:   // a popup open request is whitelisted or not. This isn't ideal
• 4985:   if (aAbuseLevel == openAbused) {
• 5001:  /* If a window open is blocked, fire the appropriate DOM events.
• 5003:   aWindow signifies we just opened what is probably a popup.
• 5011:   // fetch the URI of the window requesting the opened window
• 5026:   // first, fetch the opener's base URI
• 5063:  nsGlobalWindow::Open(const nsAString& aUrl, const nsAString& aName,
• 5066:   return OpenInternal(aUrl, aName, aOptions,
• 5078:  nsGlobalWindow::OpenJS(const nsAString& aUrl, const nsAString& aName,
• 5081:   return OpenInternal(aUrl, aName, aOptions,
• 5092:  // like Open, but attaches to the new window any extra parameters past
• 5095:  nsGlobalWindow::OpenDialog(const nsAString& aUrl, const nsAString& aName,
• 5099:   return OpenInternal(aUrl, aName, aOptions,
• 5111:  nsGlobalWindow::OpenDialog(const nsAString& aUrl, const nsAString& aName,
• 5145:   return OpenInternal(aUrl, aName, aOptions,
• 5444:   // currently a modal dialog open. Ignore such calls.
• 5464:   // that were not opened by script
• 5466:   if (!mHadOriginalOpener && !nsContentUtils::IsCallerTrustedForWrite()) {
• 5928:  // our normal window opening code.
• 6069:   nsresult rv = OpenInternal(aURI, EmptyString(), options,
• 6200:   // The Find dialog is already open, bring it to the top.
• 6202:   } else { // Open a Find dialog
• 6205:   rv = OpenDialog(NS_LITERAL_STRING("chrome://global/content/finddialog.xul"),
• 6637:   // When a window with an open sheet loses focus, only the sheet window
• 7353:  nsGlobalWindow::OpenInternal(const nsAString& aUrl, const nsAString& aName,
• 7362:   FORWARD_TO_OUTER(OpenInternal, (aUrl, aName, aOptions, aDialog,
• 7385:   // No chrome means we don't want to go through with this open call
• 7402:   // window opening should be blocked, to ensure that we don't FireAbuseEvents
• 7403:   // for a window opening that wouldn't have succeeded in the first place.
• 7409:   window.openDialog being inaccessible from web scripts */
• 7419:   OpenAllowValue allowReason;
• 7422:   allowReason = CheckOpenAllow(abuseLevel);
• 7425:   // If script in some other window is doing a window.open on us and
• 7427:   // But if we're doing a window.open on ourselves and block the popup,
• 7456:   // Reset popup state while opening a window to prevent the
• 7458:   // dialog is open.
• 7459:   nsAutoPopupStatePusher popupStatePusher(openAbused, PR_TRUE);
• 7464:   "Unable to open windows from JS because window watcher "
• 7468:   rv = pwwatch->OpenWindowJS(this, url.get(), name_ptr, options_ptr,
• 7475:   // nsIDOMWindowInternal::OpenWindow and nsIWindowWatcher::OpenWindow.
• 7487:   rv = wwatch->OpenWindow(this, url.get(), name_ptr, options_ptr,
• 7508:   // window.open() from JavaScript, make sure there's a document in
• 7529:   if (abuseLevel >= openControlled) {
• 7530:   nsGlobalWindow *opened = static_cast<nsGlobalWindow *>(*aReturn);
• 7531:   if (!opened->IsPopupSpamWindow()) {
• 7532:   opened->SetPopupSpamWindow(PR_TRUE);
• 7533:   ++gOpenPopupSpamCount;
• 7536:   if (abuseLevel >= openAbused)
• 7698:   timeout->mPopupState = openAbused;
• 7700:   if (gRunningTimeoutDepth == 0 && gPopupControlState < openAbused) {
• 7704:   // "dom.disable_open_click_delay" is set to (in ms).
• 7707:   nsContentUtils::GetIntPref("dom.disable_open_click_delay");
• 7772:   // If a modal dialog is open for this window, return early. Pending
• 7900:   // "dom.disable_open_click_delay".
• 7904:   // timeouts from repeatedly opening poups.
• 7905:   timeout->mPopupState = openAbused;
• 7980:   // dialog was open or through other non-obvious paths.
• 8383:   NS_ASSERTION(scx, "opening window missing its context");
• 8384:   NS_ASSERTION(mDocument, "opening window missing its document");
• 8392:   // If open() is called from chrome on a non-chrome window, we'll
• 8393:   // use the context from the window on which open() is being called
• 8394:   // to prevent giving chrome priveleges to new windows opened in
• 9692:   rv = channel->Open(getter_AddRefs(stream));

• 231:   id == sOpener_id ||
• 312:   static jsval sOpen_id;
• 321:   static jsval sOpener_id;
• 880:   static JSBool DocumentOpen(JSContext *cx, JSObject *obj, uintN argc,

• 1418:  jsval nsDOMClassInfo::sOpen_id = JSVAL_VOID;
• 1427:  jsval nsDOMClassInfo::sOpener_id = JSVAL_VOID;
• 1609:   SET_JSVAL_TO_STRING(sOpen_id, cx, "open");
• 1618:   SET_JSVAL_TO_STRING(sOpener_id, cx, "opener");
• 4348:   sOpen_id = JSVAL_VOID;
• 4356:   sOpener_id = JSVAL_VOID;
• 8239:  nsHTMLDocumentSH::DocumentOpen(JSContext *cx, JSObject *obj, uintN argc,
• 8245:   // DOM0 quirk that makes document.open() call window.open() if
• 8248:   return ::JS_CallFunctionName(cx, global, "open", argc, argv, rval);
• 8296:   rv = doc->Open(contentType, replace, getter_AddRefs(retval));
• 8805:   if (id == sOpen_id) {
• 8809:   DocumentOpen, 0, JSPROP_ENUMERATE);

• 128:  // permissible values for CheckOpenAllow
• 129:  enum OpenAllowValue {
• 130:   allowNot = 0, // the window opening is denied
• 295:   virtual NS_HIDDEN_(void) SetOpenerScriptPrincipal(nsIPrincipal* aPrincipal);
• 296:   virtual NS_HIDDEN_(nsIPrincipal*) GetOpenerScriptPrincipal();
• 342:   virtual NS_HIDDEN_(void) SetOpenerWindow(nsIDOMWindowInternal *aOpener,
• 343:   PRBool aOriginalOpener);
• 488:   * @param aDialog true when called from variants of OpenDialog. If this is
• 491:   * @param aCalledNoScript true when called via the [noscript] open()
• 492:   * and openDialog() methods. When this is true, we do
• 496:   * window opening. When true, popups do not cause us to
• 499:   * document in the newly-opened window. Note that this
• 500:   * last will only be done if the newly-opened window is
• 510:   * @param aReturn [out] The window that was opened, if any.
• 516:   NS_HIDDEN_(nsresult) OpenInternal(const nsAString& aUrl,
• 564:   OpenAllowValue CheckOpenAllow(PopupControlState aAbuseLevel);
• 680:   PRPackedBool mHadOriginalOpener : 1;
• 702:   nsWeakPtr mOpener;
• 730:   nsCOMPtr<nsIPrincipal> mOpenerScriptPrincipal; // strong; used to determine
• 763:   PRBool mSetOpenerWindowCalled;
• 765:   nsCOMPtr<nsIURI> mLastOpenedURI;

• 152:   * If you can't provide lock values in the open(2) call. Note, this

• 69:  #define DBFILE_OPEN(path, flag,mode) open((path), flag)
• 72:  #define DBFILE_OPEN(path, flag,mode) open((path), (flag), (mode))

• 86:  MPOOL *mpool_open (void *, int, pgno_t, pgno_t);

• 264:   * The following flags are included in the dbopen(3) call as part of the
• 265:   * open(2) flags. In order to avoid conflicts with the open flags, start
• 267:   * the open flags were significantly expanded in the future, it could be
• 268:   * a problem. Wish I'd left another flags word in the dbopen call.
• 400:  dbopen (const char *, int, int, DBTYPE, const void *);
• 403:   * opening of any DBM file
• 408:  DB *__bt_open (const char *, int, int, const BTREEINFO *, int);
• 409:  DB *__hash_open (const char *, int, int, const HASHINFO *, int);
• 410:  DB *__rec_open (const char *, int, int, const RECNOINFO *, int);

• 163:   // lay out all of our currently open popups.
• 167:   if (popupChild && popupChild->IsOpen()) {

• 139:   // there is a menu popup open for the menu bar. In this case, don't
• 142:   if (pm && pm->IsPopupOpenForMenuParent(this))
• 374:   // check if there's an open context menu, we ignore this
• 382:   PRBool wasOpen = PR_FALSE;
• 384:   wasOpen = mCurrentMenu->IsOpen();
• 386:   if (wasOpen) {
• 401:   if (wasOpen && !aMenuItem->IsDisabled())
• 418:   if (mCurrentMenu->IsOpen())

• 148:   NS_ASSERTION(!mPopups && !mNoHidePanels, "XUL popups still open");
• 182:   // widget can keep track of it so it doesn't reopen if a mouse
• 187:   // that case we don't need to deal with the menu reopening as it will
• 188:   // already still be open.
• 235:   // that are open. If a mouse click occurs outside one of these popups, the
• 244:   NS_ASSERTION(widget, "open popup has no widget");
• 246:   // In the case when a menulist inside a panel is open, clicking in the
• 589:   // use a weak frame as the popup will set an open attribute if it is a menu
• 665:   // open submenus below it. In this case, we need to make sure that those
• 749:   // possible someone added another item (attempted to open another popup)
• 945:   // When a menuitem is selected to be executed, first hide all the open
• 947:   // opens a modal dialog. The views associated with the popups needed to be
• 1060:   // if the event was cancelled, don't open the popup, and reset it's
• 1110:   // state back to open. Only popups in chrome shells can prevent a popup
• 1114:   popupFrame->SetPopupState(ePopupOpenAndVisible);
• 1124:  nsXULPopupManager::IsPopupOpen(nsIContent* aPopup)
• 1126:   // a popup is open if it is in the open list. The assertions ensure that the
• 1128:   // state, it will still be in the open popup list until it is closed.
• 1132:   NS_ASSERTION(item->Frame()->IsOpen() ||
• 1135:   "popup in open list not actually open");
• 1144:   NS_ASSERTION(item->Frame()->IsOpen() ||
• 1147:   "popup in open list not actually open");
• 1157:  nsXULPopupManager::IsPopupOpenForMenuParent(nsMenuParent* aMenuParent)
• 1162:   if (popup && popup->IsOpen()) {
• 1199:   if (item->Frame()->PopupState() == ePopupOpenAndVisible)
• 1210:   // if a popup's IsOpen method returns true, then the popup must always be in
• 1211:   // the popup chain scanned in IsPopupOpen.
• 1212:   NS_ASSERTION(!aPopup->IsOpen() || IsPopupOpen(aPopup->GetContent()),
• 1213:   "popup frame state doesn't match XULPopupManager open state");
• 1217:   // if the popup is not in the open popup chain, then it must have a state that
• 1219:   NS_ASSERTION(IsPopupOpen(aPopup->GetContent()) || state == ePopupClosed ||
• 1221:   "popup not in XULPopupManager open list is open");
• 1227:   // if the popup was just rolled up, don't reopen it
• 1243:   // chrome shells can always open popups, but other types of shells can only
• 1244:   // open popups when they are focused and visible
• 1267:   // platforms respond differently when an popup is opened in a minimized
• 1278:   // cannot open a popup that is a submenu of a menupopup that isn't open.
• 1283:   if (parentPopup && !parentPopup->IsOpen())
• 1482:  // In both cases, |mTimerMenu| is the menu item that might have an open submenu and
• 1497:  // Item A has an open submenu, and in it there is an item (B) which also has an open
• 1506:  // child, and if it does, set the selected item to A. Because B has a submenu open, it
• 1511:  // drill all the way down to the deepest open submenu and check if it has something
• 1533:   if (mTimerMenu->IsOpen())
• 1564:   nsMenuFrame* menuToOpen = result->Enter();
• 1565:   if (menuToOpen) {
• 1566:   nsCOMPtr<nsIContent> content = menuToOpen->GetContent();
• 1580:   result->OpenMenu(PR_TRUE);
• 1592:   // navigate up through the open menus, looking for the topmost one
• 1608:   // context menu opened on another menu.
• 1634:   // if a popup is open, first check for navigation within the popup
• 1650:   // Open the menu and select its first item.
• 1675:   // This method only gets called if we're open.
• 1677:   // We've been opened, but we haven't had anything selected.
• 1690:   PRBool isOpen = PR_FALSE;
• 1692:   isOpen = currentMenu->IsOpen();
• 1694:   if (isOpen) {
• 1695:   // for an open popup, have the child process the event
• 1702:   // The menu is not yet open. Open it and select the first item.
• 1728:   else if (currentMenu && isContainer && isOpen) {
• 1861:   // don't do anything if a menu isn't open or a menubar isn't active
• 1877:   // don't do anything if a menu isn't open or a menubar isn't active
• 1919:   // Since a menu was open, eat the event to keep other event
• 1930:   // When a menu is open, the prevent default flag on a keypress is always set, so
• 1959:   // if a menu is open or a menubar is active, it consumes the key event
• 1971:   // Pressing Escape hides one level of menus only. If no menu is open,
• 1993:   // If there is a popup open, check if the current item needs to be opened.
• 1995:   // Enter method will return a menu if one needs to be opened as a result.
• 1996:   nsMenuFrame* menuToOpen = nsnull;
• 1999:   menuToOpen = item->Frame()->Enter();
• 2001:   menuToOpen = mActiveMenuBar->Enter();
• 2002:   if (menuToOpen) {
• 2003:   nsCOMPtr<nsIContent> content = menuToOpen->GetContent();

• 69:  /* void openMenu (in boolean openFlag); */
• 70:  NS_IMETHODIMP nsMenuBoxObject::OpenMenu(PRBool aOpenFlag)
• 76:   if (aOpenFlag) {

• 258:   result->OpenMenu(PR_TRUE);
• 375:   if (!mMenuBarFrame->IsMenuOpen() && mMenuBarFrame->IsActive()) {
• 386:   if (!mMenuBarFrame->IsMenuOpen() && mMenuBarFrame->IsActive())

• 62:  // XUL popups can be in several different states. When opening a popup, the
• 66:  // ePopupOpen - between the popupshowing event and being visible. Creation
• 68:  // ePopupOpenAndVisible - layout is done and AdjustView is called to make
• 76:   // state when a popup is not open
• 81:   // state while a popup is open but the widget is not yet visible
• 82:   ePopupOpen,
• 83:   // state while a popup is open and visible on screen
• 84:   ePopupOpenAndVisible,
• 128:   // as popups are opened asynchronously, the popup pending state is used to
• 129:   // prevent multiple requests from attempting to open the same popup twice
• 138:   * When this popup is open, should clicks outside of it be consumed?
• 142:   * even when the popup is open.
• 212:   // called when the Enter key is pressed while the popup is open. This will
• 214:   // should be opened as a result, this method should return the frame for
• 215:   // that menu, or null if no menu should be opened. Also, calling Enter will
• 222:   PRBool IsOpen() { return mPopupState == ePopupOpen || mPopupState == ePopupOpenAndVisible; }
• 223:   PRBool HasOpenChanged() { return mIsOpenChanged; }
• 230:   // each way of opening a popup.
• 249:   // indicate that the popup should be opened
• 358:   nsPopupState mPopupState; // open state of the popup
• 364:   PRPackedBool mIsOpenChanged; // true if the open state changed since the last layout

• 173:   return NS_OK; // removed tooltip from dom while it was open
• 561:   // Clear the current tooltip if the popup was not opened successfully.
• 562:   if (!pm->IsPopupOpen(currentTooltip))

• 164:   * NOTE: OpenMenu will open the menu asynchronously.
• 166:   void OpenMenu(PRBool aSelectFirstItem);
• 177:   // the menuitem. If the menu should be opened, this frame will be returned,
• 198:   virtual PRBool IsOpen();
• 204:   // indiciate that the menu's popup has just been opened, so that the menu
• 205:   // can update its open state. This method modifies the open attribute on
• 207:   void PopupOpened();
• 209:   // can update its open state. The menu should be unhighlighted if
• 210:   // aDeselectedMenu is true. This method modifies the open attribute on
• 280:   nsCOMPtr<nsITimer> mOpenTimer;

• 63:   // new item aMenuItem. For a menubar, if another menu is already open, the
• 64:   // new menu aMenuItem is opened. In this case, if aSelectFirstItem is true,
• 65:   // select the first item in it. For menupopups, the menu is not opened and
• 69:   // returns true if the menupopup is open. For menubars, returns false.
• 70:   virtual PRBool IsOpen() = 0;

• 123:  nsPopupBoxObject::OpenPopup(nsIDOMElement* aAnchorElement,
• 140:  nsPopupBoxObject::OpenPopupAtScreen(PRInt32 aXPos, PRInt32 aYPos, PRBool aIsContextMenu)
• 239:   case ePopupOpen:
• 242:   case ePopupOpenAndVisible:
• 243:   aState.AssignLiteral("open");

• 54:  #define ROW_FLAG_OPEN 0x02
• 87:   void SetOpen(PRBool aOpen) {
• 88:   aOpen ? mFlags |= ROW_FLAG_OPEN : mFlags &= ~ROW_FLAG_OPEN;
• 90:   PRBool IsOpen() { return !!(mFlags & ROW_FLAG_OPEN); }
• 294:  nsTreeContentView::IsContainerOpen(PRInt32 aIndex, PRBool* _retval)
• 300:   *_retval = mRows[aIndex]->IsOpen();
• 572:  nsTreeContentView::ToggleOpenState(PRInt32 aIndex)
• 584:   // we don't use an attribute for optgroup's open state
• 585:   if (row->IsOpen())
• 588:   OpenContainer(aIndex);
• 591:   if (row->IsOpen())
• 592:   row->mContent->SetAttr(kNameSpaceID_None, nsGkAtoms::open, NS_LITERAL_STRING("false"), PR_TRUE);
• 594:   row->mContent->SetAttr(kNameSpaceID_None, nsGkAtoms::open, NS_LITERAL_STRING("true"), PR_TRUE);
• 893:   else if (aAttribute == nsGkAtoms::open) {
• 894:   PRBool isOpen =
• 895:   aContent->AttrValueIs(kNameSpaceID_None, nsGkAtoms::open,
• 897:   PRBool wasOpen = row->IsOpen();
• 898:   if (! isOpen && wasOpen)
• 900:   else if (isOpen && ! wasOpen)
• 901:   OpenContainer(index);
• 1015:   if (row->IsContainer() && row->IsOpen()) {
• 1179:   if (aContent->AttrValueIs(kNameSpaceID_None, nsGkAtoms::open,
• 1181:   row->SetOpen(PR_TRUE);
• 1238:   row->SetOpen(PR_TRUE);
• 1273:   content->AttrValueIs(kNameSpaceID_None, nsGkAtoms::open,
• 1370:   // we can be sure that all other parents are open too.
• 1373:   // Got it, now test if it is open.
• 1374:   if (mRows[grandParentIndex]->IsOpen())
• 1456:  nsTreeContentView::OpenContainer(PRInt32 aIndex)
• 1459:   row->SetOpen(PR_TRUE);
• 1472:   row->SetOpen(PR_FALSE);

• 373:   // Examples include container, open, selected, and focus.
• 438:   // opening/closing folders or tree scrolling.
• 445:   static void OpenCallback(nsITimer *aTimer, void *aClosure);
• 527:   // Timer for opening/closing spring loaded folders or scrolling the tree.

• 2029:   // open or closed
• 2030:   PRBool isOpen = PR_FALSE;
• 2031:   mView->IsContainerOpen(aRowIndex, &isOpen);
• 2032:   if (isOpen)
• 2033:   mScratchArray->AppendElement(nsGkAtoms::open);
• 2706:   // If over a folder, start up a timer to open the folder.
• 2710:   PRBool isOpen = PR_FALSE;
• 2711:   mView->IsContainerOpen(mSlots->mDropRow, &isOpen);
• 2712:   if (!isOpen) {
• 2714:   CreateTimer(nsILookAndFeel::eMetric_TreeOpenDelay,
• 2715:   OpenCallback, nsITimer::TYPE_ONE_SHOT,
• 2947:   // XXX Automatically fill in the following props: open, closed, container, leaf, selected, focused
• 3147:   // XXX Automatically fill in the following props: open, closed, container, leaf, selected, focused, and the col ID.
• 4417:  nsTreeBodyFrame::OpenCallback(nsITimer *aTimer, void *aClosure)
• 4426:   self->mView->ToggleOpenState(self->mSlots->mDropRow);
• 4441:   self->mView->ToggleOpenState(self->mSlots->mArray[i]);

• 115:   void OpenContainer(PRInt32 aIndex);

• 82:   * and if so, whether an open or closed twisty should be used.
• 85:   boolean isContainerOpen(in long index);
• 174:   * Called on the view when an item is opened or closed.
• 176:   void toggleOpenState(in long index);

• 382:   if (mOpenTimer) {
• 383:   mOpenTimer->Cancel();
• 441:   // On mac, open menulist on either up/down arrow or space (w/o Cmd pressed)
• 442:   if (!IsOpen() && ((keyEvent->charCode == NS_VK_SPACE && !keyEvent->isMeta) ||
• 445:   OpenMenu(PR_FALSE);
• 468:   if (!IsOpen()) {
• 469:   OpenMenu(PR_FALSE);
• 508:   if (mOpenTimer) {
• 509:   mOpenTimer->Cancel();
• 510:   mOpenTimer = nsnull;
• 517:   if (IsMenu() && !onmenubar && IsOpen()) {
• 546:   // Hovering over a menu in a popup should open it without a need for a click.
• 547:   // A timer is used so that it doesn't open if the user moves the mouse quickly
• 550:   if (!IsDisabled() && IsMenu() && !IsOpen() && !mOpenTimer && !mMenuParent->IsMenuBar()) {
• 558:   mOpenTimer = do_CreateInstance("@mozilla.org/timer;1");
• 559:   mOpenTimer->InitWithCallback(mTimerMediator, menuDelay, nsITimer::TYPE_ONE_SHOT);
• 569:   if (IsOpen())
• 572:   OpenMenu(PR_FALSE);
• 576:  nsMenuFrame::PopupOpened()
• 579:   mContent->SetAttr(kNameSpaceID_None, nsGkAtoms::open,
• 597:   new nsUnsetAttrRunnable(mContent, nsGkAtoms::open));
• 624:   // When a menu opens a submenu, the mouse will often be moved onto a
• 689:  nsMenuFrame::OpenMenu(PRBool aSelectFirstItem)
• 699:   // This opens the menu asynchronously
• 768:   // if the menu has just been opened, or its size changed, position
• 769:   // the popup. The flag that the popup checks in the HasOpenChanged
• 771:   if (IsOpen() && (sizeChanged || mPopupFrame->HasOpenChanged()))
• 865:   if (!IsOpen()) {
• 877:  nsMenuFrame::IsOpen()
• 879:   return mPopupFrame && mPopupFrame->IsOpen();
• 892:   if (aTimer == mOpenTimer.get()) {
• 893:   mOpenTimer = nsnull;
• 895:   if (!IsOpen() && mMenuParent) {
• 896:   // make sure we didn't open a context menu in the meantime
• 903:   OpenMenu(PR_FALSE);

• 148:   enum State { Open, CollapsedBefore, CollapsedAfter, Dragging };
• 249:   return Open;
• 336:   mInner->mState = nsSplitterFrameInner::Open;
• 387:   mInner->mState = nsSplitterFrameInner::Open;
• 507:   // if the state is dragging then make it Open.
• 960:   // Open -> Dragging
• 961:   // Open -> CollapsedBefore
• 962:   // Open -> CollapsedAfter
• 963:   // CollapsedBefore -> Open
• 965:   // CollapsedAfter -> Open
• 967:   // Dragging -> Open
• 993:   // CollapsedBefore -> Open
• 995:   // CollapsedAfter -> Open
• 999:   } else if ((mState == Open || mState == Dragging)
• 1002:   // Open -> CollapsedBefore / CollapsedAfter

• 142:   // tooltip can be opened at this location.

• 114:   mIsOpenChanged(PR_FALSE),
• 179:   // the popup opens.
• 340:   // menu popups generate their child frames lazily only when opened, so
• 361:   if ((mPopupState == ePopupOpen || mPopupState == ePopupOpenAndVisible) &&
• 363:   // if the popup has just opened, make sure the scrolled window is at 0,0
• 364:   if (mIsOpenChanged) {
• 377:   mPopupState = ePopupOpenAndVisible;
• 383:   if (mIsOpenChanged) {
• 384:   mIsOpenChanged = PR_FALSE;
• 552:   // this popup opening function is provided for backwards compatibility
• 614:   mPopupState = ePopupOpen;
• 615:   mIsOpenChanged = PR_TRUE;
• 620:   (static_cast<nsMenuFrame*>(parent))->PopupOpened();
• 654:   // don't hide the popup when it isn't open
• 673:   mIsOpenChanged = PR_FALSE;
• 896:   // if the frame is not specified, use the anchor node passed to OpenPopup. If
• 986:   // mXPos and mYPos specify an additonal offset passed to OpenPopup that
• 1251:   // When a context menu is open, the current menu is locked, and no change
• 1262:   if (mCurrentMenu->IsOpen()) {

• 77:   virtual PRBool IsOpen() { return PR_TRUE; } // menubars are considered always open
• 79:   PRBool IsMenuOpen() { return mCurrentMenu && mCurrentMenu->IsOpen(); }
• 106:   // menu is open, let the child handle the key.
• 135:   // The current menu that is active (highlighted), which may not be open. This will

• 51:   virtual PRBool IsOpen() = 0;

• 47:   void openMenu(in boolean openFlag);

• 48:   * This method is deprecated. Use openPopup or openPopupAtScreen instead.
• 56:   * Hide the popup if it is open.
• 80:   * on an open popup.
• 106:   * Open the popup relative to a specified node at a specific location.
• 108:   * The popup may be either anchored to another node or opened freely.
• 140:   void openPopup(in nsIDOMElement anchorElement,
• 147:   * Open the popup at a specific screen position specified by x and y. This
• 158:   void openPopupAtScreen(in long x, in long y, in boolean isContextMenu);
• 163:   * open - the popup is open

• 38:   * The XUL Popup Manager keeps track of all open popups.
• 62:   * - panels, which stay open until a request is made to close them. This
• 65:   * When a new popup is opened, it is appended to the popup chain, stored in a
• 69:   * occurs outside one of the open dismissable popups, the chain is closed by
• 149:  // nsMenuChainItem holds info about an open popup. Items are stored in a
• 370:   // either because one of its menus has opened or closed, or that the menubar
• 378:   // retrieve the node and offset of the last mouse event used to open a
• 386:   * Open a <menu> given its content node. If aSelectFirstItem is
• 394:   * Open a popup, either anchored or unanchored. If aSelectFirstItem is
• 396:   * similar to those for nsIPopupBoxObject::OpenPopup.
• 415:   * Open a popup at a specific screen position specified by aXPos and aYPos,
• 486:   * Return true if the popup for the supplied content node is open.
• 488:   PRBool IsPopupOpen(nsIContent* aPopup);
• 491:   * Return true if the popup for the supplied menu parent is open.
• 493:   PRBool IsPopupOpenForMenuParent(nsMenuParent* aMenuParent);
• 496:   * Return the frame for the topmost open popup of a given type, or null if
• 497:   * no popup of that type is open. If aType is ePopupTypeAny, a menu of any
• 503:   * Return an array of all the open and visible popup frames for
• 509:   * Return false if a popup may not be opened. This will return false if the
• 510:   * popup is already open, if the popup is in a content shell that is not
• 511:   * focused, or if it is a submenu of another menu that isn't open.
• 523:   * Returns true if there is a context menu open. If aPopup is specified,
• 525:   * is null, returns true if any context menu at all is open.
• 546:   * close is aMenuParent. When a submenu is opened, the user might move the
• 623:   * Fire a popupshowing event on the popup aPopup and then open the popup.
• 627:   * aPopup - the popup node to open
• 645:   * of open menus. If these are not set, only one popup is closed. However,
• 681:   * an open submenu if one exists. Returns true if the key was
• 702:   * usually only be attached when the first menu opens and removed when all
• 705:   * This is also used when only a menubar is active without any open menus,

• 286:   // then open or close the combo box.

• 196:   // to open file dialog on mouse click
• 228:   // to open file dialog on mouse click
• 301:   result = filePicker->Init(win, title, nsIFilePicker::modeOpen);
• 336:   // Open dialog

• 124:   * combo box is toggled to open or close. this is used by Accessibility which presses
• 1037:   // then open or close the combo box.

• 1844:   * Open issues with the special height reflow:

• 370:  // ms:before { content: open-quote; }

• 896:   // from a generated content such as :before { content: open-quote } or

• 101:   nsMathMLChar* aOpenChar,
• 109:   nsMathMLChar* aOpenChar,
• 140:   nsMathMLChar* mOpenChar;

• 116:   if (mOpenChar) delete mOpenChar;
• 120:   mOpenChar = nsnull;
• 133:   // see if the opening fence is there ...
• 134:   if (!GetAttribute(mContent, mPresentationData.mstyle, nsGkAtoms::open,
• 143:   mOpenChar = new nsMathMLChar;
• 144:   if (!mOpenChar) return NS_ERROR_OUT_OF_MEMORY;
• 145:   mOpenChar->SetData(aPresContext, value);
• 147:   ResolveMathMLCharStyle(aPresContext, mContent, mStyleContext, mOpenChar, isMutable);
• 219:   if (mOpenChar) {
• 220:   rv = mOpenChar->Display(aBuilder, this, aLists);
• 243:   mOpenChar, mCloseChar, mSeparatorsChar, mSeparatorsCount);
• 249:   return doGetIntrinsicWidth(aRenderingContext, this, mOpenChar, mCloseChar,
• 261:   nsMathMLChar* aOpenChar,
• 301:   if (firstChild || aOpenChar || aCloseChar || aSeparatorsCount > 0) {
• 382:   // Prepare the opening fence, separators, and closing fence, and
• 394:   // opening fence ...
• 395:   ReflowChar(aPresContext, *aReflowState.rendContext, aOpenChar,
• 419:   if (aOpenChar) {
• 420:   PlaceChar(aOpenChar, ascent, bm, dx);
• 626:   nsMathMLChar* aOpenChar,
• 639:   if (aOpenChar) {
• 641:   GetMaxCharWidth(presContext, aRenderingContext, aOpenChar,
• 680:   if (mOpenChar) {
• 681:   mOpenChar->GetRect(rect);
• 683:   mOpenChar->SetRect(rect);
• 703:   PRInt32 openIndex = -1;
• 707:   if (mOpenChar) {
• 709:   openIndex = lastIndex;
• 722:   else if (aIndex == openIndex) {
• 723:   return mOpenChar->GetStyleContext();
• 735:   PRInt32 openIndex = -1;
• 739:   if (mOpenChar) {
• 741:   openIndex = lastIndex;
• 754:   else if (aIndex == openIndex) {
• 755:   mOpenChar->SetStyleContext(aStyleContext);

• 323:   const ComputedStyleMapEntry* propEntry = nsnull;
• 329:   propEntry = &propMap[i];
• 334:   if (!propEntry) {
• 349:   propEntry->mNeedsLayoutFlush ? Flush_Layout : Flush_Style);
• 351:   mFlushedPendingReflows = propEntry->mNeedsLayoutFlush;
• 384:   nsresult rv = (this->*(propEntry->mGetter))(aReturn);
• 770:   case eStyleContentType_OpenQuote:
• 771:   val->SetIdent(eCSSKeyword_open_quote);
• 776:   case eStyleContentType_NoOpenQuote:
• 777:   val->SetIdent(eCSSKeyword_no_open_quote);
• 998:   nsROCSSPrimitiveValue* openVal = GetROCSSPrimitiveValue();
• 999:   if (!openVal || !valueList->AppendCSSValue(openVal)) {
• 1001:   delete openVal;
• 1013:   nsStyleUtil::AppendEscapedCSSString(*quotes->OpenQuoteAt(i), s);
• 1014:   openVal->SetString(s);

• 360:  CSS_KEY(no-open-quote, no_open_quote)
• 371:  CSS_KEY(open-quote, open_quote)
• 520:  CSS_KEY(treetwistyopen, treetwistyopen)

• 396:   eCSSKeyword_treetwistyopen, NS_THEME_TREEVIEW_TWISTY_OPEN,
• 680:   eCSSKeyword_open_quote, NS_STYLE_CONTENT_OPEN_QUOTE,
• 682:   eCSSKeyword_no_open_quote, NS_STYLE_CONTENT_NO_OPEN_QUOTE,

• 189:   // "loading datas" table (right after the async channel is opened)

• 1277:   * supposed to be synchronous it just opens a channel synchronously
• 1315:   rv = NS_OpenURI(getter_AddRefs(stream), aLoadData->mURI, nsnull,
• 1319:   LOG_ERROR((" Failed to open URI synchronously"));
• 1324:   NS_ASSERTION(channel, "NS_OpenURI lied?");
• 1455:   // this before opening it, so it's only treated as a hint.
• 1478:   rv = channel->AsyncOpen(streamLoader, nsnull);
• 1670:   // being parsed (eg if the child (us) failed to open the channel

• 305:   rv = channel->AsyncOpen(streamLoader, nsnull);
• 316:   rv = channel->AsyncOpen(listener, nsnull);

• 950:   // Silently deleting \0 opens a content-filtration loophole (see

• 411:   // Note that we can hit this codepath multiple times when document.open()

• 1072:   eStyleContentType_OpenQuote = 40,
• 1074:   eStyleContentType_NoOpenQuote = 42,
• 1130:   const nsString* OpenQuoteAt(PRUint32 aIndex) const
• 1140:   nsresult GetQuotesAt(PRUint32 aIndex, nsString& aOpen, nsString& aClose) const {
• 1143:   aOpen = mQuotes[aIndex];
• 1165:   nsresult SetQuotesAt(PRUint32 aIndex, const nsString& aOpen, const nsString& aClose) {
• 1168:   mQuotes[aIndex] = aOpen;

• 4803:   case NS_STYLE_CONTENT_OPEN_QUOTE:
• 4804:   type = eStyleContentType_OpenQuote; break;
• 4807:   case NS_STYLE_CONTENT_NO_OPEN_QUOTE:
• 4808:   type = eStyleContentType_NoOpenQuote; break;

• 482:   // ParseHSLColor parses everything starting with the opening '('
• 1286:   // CSS2.1 specifies that all "open constructs" are to be closed at
• 7829:   nsCSSValue open;
• 7830:   if (ParseVariant(open, VARIANT_HOS, nsnull)) {
• 7831:   if (eCSSUnit_String == open.GetUnit()) {
• 7838:   quotes->mXValue = open;
• 7848:   // look for another open
• 7849:   if (ParseVariant(open, VARIANT_STRING, nsnull)) {
• 7853:   quotes->mXValue = open;
• 7866:   quotesHead->mXValue = open;

• 194:  #define MAX_DEPTH_FOR_LIST_RENUMBERING 200 // 200 open displayable tags is pretty unrealistic

• 7280:   FILE* inFile = fopen(path, "r");

• 106:   open,
• 108:   openClose
• 301:   : name(nsnull), type(open), attributes(nsnull), num(0), size(0),
• 437:   type = openClose;
• 473:   tag->type = open;
• 503:   if (type == openClose) {

• 696:   // there is enough open space below which is not impacted by a

• 524:   // openDialog("something.html") to produce an opaque window
• 631:   // widgets for popups can be created later when the popup is opened,
• 632:   // so if there is no widget, the popup won't be open.

• 722:   // when a content panel is no longer primary, hide any open popups it may have

• 1195:   PR_LOG(nsObjectFrameLM, PR_LOG_DEBUG, ("error: could not open tmp. file, errno=%d\n", errno));

• 332:   // Now update the right edges of the open spans to account for any

• 979:   c) The caret is not hidden due to open XUL popups
• 1016:   // Check if there are open popups.
• 1036:   // If there's a menu popup open before the popup with
• 1049:   // This is an open menu popup. It does not contain the caret (else we'd
• 1057:   // There are no open menu popups, no need to hide the caret.

• 831:   // it in one place (Show()) and require that callers call init(), open(),
• 1095:   nsAutoPopupStatePusher popupStatePusher(openAbused, PR_TRUE);
• 1210:   nsAutoPopupStatePusher popupStatePusher(openAbused, PR_TRUE);
• 1216:   // look for open menupopups and close them after the unload event, in case
• 1217:   // the unload event listeners open any new popups
• 1264:  DocumentViewerImpl::Open(nsISupports *aState, nsISHEntry *aSHEntry)
• 1480:   // When the presentation is restored, Open() and InitInternal() will reset

• 1732:   if (valueString.LowerCaseEqualsASCII("opentype")) {
• 1733:   face->mFormatFlags |= gfxUserFontSet::FLAG_FORMAT_OPENTYPE;
• 1738:   } else if (valueString.LowerCaseEqualsASCII("embedded-opentype")) {

• 266:   // 1. An open popup contains the caret, but a menu popup exists before the
• 270:   // 2. A menu popup is open, but there is no caret present in any popup.

• 58:   // Don't set up text for 'no-open-quote' and 'no-close-quote'.
• 68:   NS_ASSERTION(mType == eStyleContentType_OpenQuote ||
• 87:   result = eStyleContentType_OpenQuote == mType
• 88:   ? styleQuotes->OpenQuoteAt(quoteDepth)
• 135:   case (eStyleContentType_OpenQuote):
• 136:   printf("open");
• 138:   case (eStyleContentType_NoOpenQuote):
• 139:   printf("noOpen");

• 1804:   case eStyleContentType_OpenQuote:
• 1806:   case eStyleContentType_NoOpenQuote:

• 1347:   * context menu when the keyboard shortcut is used to open it.
• 1349:   * If another menu is open, the context menu is opened relative to the
• 1351:   * Otherwise, if the caret is visible, the menu is opened near the caret.
• 1353:   * current item within the menu is opened relative to this item.
• 1354:   * Otherwise, the context menu is opened at the topleft corner of the
• 6343:   // if a menu is open, open the context menu relative to the active item on the menu.
• 6345:   // menu is open. Maybe we should prevent keyboard-tiggered context menu events too.
• 6351:   // context menus should not be opened while another menu is open on Mac,
• 8390:   mFD = fopen(name, "w");

• 133:   // inside popups so that it is only created when the popup is opened.

• 59:   // which is needed to do 'content: open-quote open-quote' correctly,
• 63:   // null for 'content:no-open-quote', 'content:no-close-quote' and for

• 46:   // open-quote, close-quote, no-open-quote, or no-close-quote
• 57:   NS_ASSERTION(aType == eStyleContentType_OpenQuote ||
• 59:   aType == eStyleContentType_NoOpenQuote ||
• 68:   // is this 'open-quote' or 'no-open-quote'?
• 69:   PRBool IsOpenQuote() {
• 70:   return mType == eStyleContentType_OpenQuote ||
• 71:   mType == eStyleContentType_NoOpenQuote;
• 76:   return !IsOpenQuote();
• 79:   // is this 'open-quote' or 'close-quote'?
• 81:   return mType == eStyleContentType_OpenQuote ||
• 89:   return IsOpenQuote() ? mDepthBefore : mDepthBefore - 1;
• 94:   return IsOpenQuote() ? mDepthBefore + 1

• 320:  #define NS_STYLE_CONTENT_OPEN_QUOTE 0
• 322:  #define NS_STYLE_CONTENT_NO_OPEN_QUOTE 2

• 49:   /* Open the progress dialog
• 52:   void openProgressDialog(in nsIDOMWindowInternal parent,
• 55:   in nsIObserver openDialogObserver,
• 56:   out boolean notifyOnOpen);

• 1017:   // Now open the service to get the progress dialog
• 1546:   NS_ERROR_TO_LOCALIZED_PRINT_ERROR_MSG(NS_ERROR_GFX_PRINTER_COULD_NOT_OPEN_FILE)
• 2047:   FILE * fd = fopen(filename, "w");
• 3459:   FILE * fd = aFD?aFD:fopen(filename, "w");
• 3581:   fd = fopen("tree_layout.txt", "w");

• 1421:   FILE *f = fopen(fname, "wb");

• 83:   PRBool isOpen;
• 95:   isOpen(PR_FALSE),
• 492:  inDOMView::IsContainerOpen(PRInt32 index, PRBool *_retval)
• 498:   *_retval = node->isOpen;
• 566:  inDOMView::ToggleOpenState(PRInt32 index)
• 573:   if (node->isOpen)
• 769:   if (!contentNode->isOpen) {
• 881:   if (!parentNode->isOpen) {
• 882:   // Parent is not open, so don't bother creating tree rows for the
• 955:   // but if we're open it's more.
• 958:   if (oldNode->isOpen)
• 968:   parentNode->isOpen = PR_FALSE;
• 1115:   node->isOpen = PR_TRUE;
• 1132:   node->isOpen = PR_FALSE;

• 294:   // downward opening is found, or the top of the tree
• 302:   if (subject) { // found a downward opening

• 133:   * Open a container row, inserting the container's children into
• 137:   OpenContainer(PRInt32 aIndex, nsIXULTemplateResult* aResult);
• 140:   * Helper for OpenContainer, recursively open subtrees, remembering
• 141:   * persisted ``open'' state
• 144:   OpenSubtreeOf(nsTreeRows::Subtree* aSubtree,
• 150:   OpenSubtreeForQuerySet(nsTreeRows::Subtree* aSubtree,
• 155:   nsTArray<PRInt32>& open);
• 171:   * Helper methods that determine if the specified container is open.
• 174:   IsContainerOpen(nsIXULTemplateResult *aResult, PRBool* aOpen);
• 177:   IsContainerOpen(nsIRDFResource* aResource, PRBool* aOpen);
• 240:   * The datasource that's used to persist open folder information
• 534:  nsXULTreeBuilder::IsContainerOpen(PRInt32 aIndex, PRBool* aOpen)
• 543:   PRBool isOpen;
• 544:   IsContainerOpen(iter->mMatch->mResult, &isOpen);
• 546:   iter->mContainerState = isOpen
• 547:   ? nsTreeRows::eContainerState_Open
• 551:   *aOpen = (iter->mContainerState == nsTreeRows::eContainerState_Open);
• 776:   // Get the datasource we intend to use to remember open state.
• 818:  nsXULTreeBuilder::ToggleOpenState(PRInt32 aIndex)
• 831:   // don't open containers if child processing isn't allowed
• 844:   observer->OnToggleOpenState(aIndex);
• 849:   PRBool isOpen;
• 850:   IsContainerOpen(aIndex, &isOpen);
• 858:   IsContainerOpen(container, &hasProperty);
• 860:   if (isOpen) {
• 863:   nsXULContentUtils::NC_open,
• 872:   nsXULContentUtils::NC_open,
• 877:   OpenContainer(aIndex, result);
• 1100:   // Get the reference point and check if it is an open container. Rows
• 1121:   return (iter->mContainerState == nsTreeRows::eContainerState_Open);
• 1196:   // is open or closed.
• 1197:   PRBool open = PR_FALSE;
• 1198:   IsContainerOpen(row, &open);
• 1200:   // If it's open, make sure that we've got a subtree structure ready.
• 1201:   if (open)
• 1205:   // container, so whether its open or closed, make sure
• 1219:   // If we get here, then we're inserting into an open
• 1247:   // See if this newly added row is open; in which case,
• 1254:   // don't open containers if child processing isn't allowed
• 1260:   PRBool open;
• 1261:   IsContainerOpen(result, &open);
• 1262:   if (open)
• 1263:   OpenContainer(iter.GetRowIndex(), result);
• 1377:   OpenContainer(-1, mRootResult);
• 1480:  nsXULTreeBuilder::OpenContainer(PRInt32 aIndex, nsIXULTemplateResult* aResult)
• 1482:   // A row index of -1 in this case means ``open tree body''
• 1494:   iter->mContainerState = nsTreeRows::eContainerState_Open;
• 1503:   OpenSubtreeOf(container, aIndex, aResult, &count);
• 1518:  nsXULTreeBuilder::OpenSubtreeOf(nsTreeRows::Subtree* aSubtree,
• 1523:   nsAutoTArray<PRInt32, 8> open;
• 1530:   OpenSubtreeForQuerySet(aSubtree, aIndex, aResult, queryset, &count, open);
• 1533:   // Now recursively deal with any open sub-containers that just got
• 1535:   for (PRInt32 i = open.Length() - 1; i >= 0; --i) {
• 1536:   PRInt32 index = open[i];
• 1544:   OpenSubtreeOf(child, aIndex + index, result, &delta);
• 1562:  nsXULTreeBuilder::OpenSubtreeForQuerySet(nsTreeRows::Subtree* aSubtree,
• 1567:   nsTArray<PRInt32>& open)
• 1670:   // If this is open, then remember it so we can recursively add
• 1672:   PRBool isOpen = PR_FALSE;
• 1673:   IsContainerOpen(nextresult, &isOpen);
• 1674:   if (isOpen) {
• 1675:   if (open.AppendElement(count) == nsnull)
• 1751:   if ((row.mContainerState == nsTreeRows::eContainerState_Open) && row.mSubtree)
• 1759:  nsXULTreeBuilder::IsContainerOpen(nsIXULTemplateResult *aResult, PRBool* aOpen)
• 1761:   // items are never open if recursion is disabled
• 1763:   *aOpen = PR_FALSE;
• 1772:   return IsContainerOpen(id, aOpen);
• 1776:  nsXULTreeBuilder::IsContainerOpen(nsIRDFResource* aResource, PRBool* aOpen)
• 1780:   nsXULContentUtils::NC_open,
• 1783:   aOpen);
• 1785:   *aOpen = PR_FALSE;

• 196:   rv = req->OpenRequest(NS_LITERAL_CSTRING("GET"), uriStr, PR_TRUE,

• 260:   rv = storage->OpenDatabase(databaseFile, getter_AddRefs(connection));

• 239:   // it's an open ended query on the source or

• 71:   eContainerState_Open = 1,

• 377:   // it's an open ended query on the container or member. go

• 44:  XUL_RESOURCE(NC_open, NC_NAMESPACE_URI "open");

• 297:   // Account for open subtrees in the absolute row index.
• 312:   // Account for open subtrees in the absolute row index.

• 134:   OpenContainer(nsIContent* aElement);
• 271:   IsOpen(nsIContent* aElement);
• 1041:   if (!aForceCreation && !IsOpen(aElement))
• 1302:  nsXULContentBuilder::IsOpen(nsIContent* aElement)
• 1315:   return aElement->AttrValueIs(kNameSpaceID_None, nsGkAtoms::open,
• 1473:   // when a menu is about to be opened, so the content should be built anyway.
• 1474:   if (!aForceCreation && !IsOpen(aElement))
• 1572:   // Handle "open" and "close" cases. We do this handling before
• 1576:   (aAttribute == nsGkAtoms::open)) {
• 1577:   // We're on a XUL tag, and an ``open'' attribute changed.
• 1578:   if (aContent->AttrValueIs(kNameSpaceID_None, nsGkAtoms::open,
• 1580:   OpenContainer(aContent);
• 1644:   // yet been opened.
• 1756:  nsXULContentBuilder::OpenContainer(nsIContent* aElement)

• 463:   * Those results will be generated when the container is opened.

• 334:   * generate its contents if it is open. This behaviour is used with menus.
• 378:   * Called when an item is opened or closed.
• 380:   void onToggleOpenState (in long index);

• 64:   // false, the popup opens on left click on aElement or a descendant. If
• 65:   // aIsContext is true, the popup is a context menu which opens on a
• 91:   // open the popup. aEvent is the event that triggered the popup such as
• 106:   // When a context menu is opened, focus the target of the contextmenu event.

• 160:   Recent numbers after opening four browser windows:

• 181:   // If the target node is for plug-in, we should not open XUL context
• 246:   // Only open popups when the left mouse button is down.
• 252:   // Open the popup and cancel the default handling of the event.
• 467:   // element, otherwise just open it at the screen position where the mouse
• 468:   // was clicked. Context menus always open at the mouse position.

• 416:   // close open streams to it.
• 695:   // the FastLoad input stream open for the life of the app.
• 836:   // that can't do open-unlink.

• 2812:   rv = NS_OpenURI(listener, nsnull, aURI, nsnull, group);
• 2821:   // Just move on to the next overlay. NS_OpenURI could fail
• 2822:   // just because a channel could not be opened, which can happen
• 2833:   // each time. We must do this after NS_OpenURI and AsyncOpen,
• 3513:   // from the FastLoad file, XULContentSinkImpl::OpenScript (over in

• 99:   nsresult OpenRoot(const PRUnichar** aAttributes,
• 103:   nsresult OpenTag(const PRUnichar** aAttributes,
• 108:   // If OpenScript returns NS_OK and after it returns our state is eInScript,
• 114:   nsresult OpenScript(const PRUnichar** aAttributes,

• 529:   rv = OpenRoot(aAtts, aAttsCount, nodeInfo);
• 533:   rv = OpenTag(aAtts, aAttsCount, aLineNumber, nodeInfo);
• 627:   // it'll have been created via XULContentSinkImpl::OpenRoot().
• 839:  XULContentSinkImpl::OpenRoot(const PRUnichar** aAttributes,
• 897:  XULContentSinkImpl::OpenTag(const PRUnichar** aAttributes,
• 943:   rv = OpenScript(aAttributes, aLineNumber);
• 949:   // OpenScript has pushed the nsPrototypeScriptElement onto the
• 969:  XULContentSinkImpl::OpenScript(const PRUnichar** aAttributes,

• 193:   NS_ASSERTION(mCurrent, "can't set attrib w/o open element");
• 203:   NS_ASSERTION(mCurrent, "can't append textnode w/o open element");

• 80:   rv = xhr->OpenRequest(getString, testURL, PR_FALSE, empty, empty);
• 82:   TEST_ENSURE_FAILED(rv, "OpenRequest should have failed!");
• 95:   rv = xhr->OpenRequest(getString, testURL, PR_FALSE, empty, empty);
• 96:   TEST_ENSURE_SUCCESS(rv, "OpenRequest failed!");

• 40:   * subframes, etc from protocols that don't return data but rather open
• 70:   // plugin, so they don't necessarily open external apps

• 610:   the OL opening tags are supposed to push an olState object to the stack*/
• 940:  nsXHTMLContentSerializer::LineBreakBeforeOpen(PRInt32 aNamespaceID, nsIAtom* aName)
• 971:  nsXHTMLContentSerializer::LineBreakAfterOpen(PRInt32 aNamespaceID, nsIAtom* aName)

• 1361:   nsCOMPtr<nsIDOMNode> opEndNode;
• 1362:   PRInt32 opStartOffset, opEndOffset;
• 1368:   rv = GetPromotedPoint( kEnd, endNode, endOffset, address_of(opEndNode), &opEndOffset, common);
• 1372:   if ( (opStartNode == common) && (opEndNode == common) )
• 1374:   rv = PromoteAncestorChain(address_of(opStartNode), &opStartOffset, &opEndOffset);
• 1376:   opEndNode = opStartNode;
• 1382:   rv = inRange->SetEnd(opEndNode, opEndOffset);

• 214:   PRBool lineBreakBeforeOpen = LineBreakBeforeOpen(content->GetNameSpaceID(), name);
• 217:   if (mColPos && lineBreakBeforeOpen) {
• 299:   !mDoRaw && LineBreakAfterOpen(content->GetNameSpaceID(), name)) {
• 347:   the OL opening tags are supposed to push an olState object to the stack*/

• 895:   rv = aViewer->Open(nsnull, nsnull);
• 1124:   return channel->AsyncOpen(this, nsnull);

• 96:   virtual PRBool LineBreakBeforeOpen(PRInt32 aNamespaceID, nsIAtom* aName);
• 97:   virtual PRBool LineBreakAfterOpen(PRInt32 aNamespaceID, nsIAtom* aName);

• 82:   * @param aChannel The channel that aIn was opened from.

• 549:   rv = uriLoader->OpenChannel(chan, nsIURILoader::DONT_RETARGET, req,
• 1322:   // AsyncOpen can fail if a file does not exist.
• 1324:   rv = chan->AsyncOpen(this, nsnull);
• 1326:   LOG(("OBJLC [%p]: Channel opened.\n", this));

• 401:   rv = DoOpenContainer(nsnull, id);
• 466:  nsPlainTextSerializer::OpenContainer(const nsIParserNode& aNode)
• 475:   return DoOpenContainer(&aNode, type);
• 518:  nsPlainTextSerializer::OpenHead()
• 547:  nsPlainTextSerializer::DoOpenContainer(const nsIParserNode* aNode, PRInt32 aTag)
• 878:   // open tag had set the mIgnoreAboveIndex value.
• 903:   // Keep this in sync with DoOpenContainer!
• 1467:   * "- -- ", the OpenPGP dash-escaped signature separator in inline
• 1468:   * signed messages according to the OpenPGP standard (RFC 2440).
• 1974:   * "The Single UNIX Specification, Version 2, The Open Group, 1997"

• 105:   NS_IMETHOD OpenContainer(const nsIParserNode& aNode);
• 116:   NS_IMETHOD OpenHead();
• 147:   nsresult DoOpenContainer(const nsIParserNode* aNode, PRInt32 aTag);
• 226:   // Hence opening tags are guaranteed to start with appropriate line breaks.
• 246:   // Values gotten in OpenContainer that is (also) needed in CloseContainer
• 270:   // variable, but that causes issues with OpenBSD and module unloading.

• 107:  #define XML_HTTP_REQUEST_OPENED (1 << 1) // 1 aka LOADING
• 134:   XML_HTTP_REQUEST_OPENED | \
• 447:   rv = mOuterChannel->AsyncOpen(mOuterListener, mOuterContext);
• 1287:   XML_HTTP_REQUEST_OPENED |
• 1304:   // if they load a new url will cause nsXMLHttpRequest::OpenRequest to clear
• 1593:  /* noscript void openRequest (in AUTF8String method, in AUTF8String url, in boolean async, in AString user, in AString password); */
• 1595:  nsXMLHttpRequest::OpenRequest(const nsACString& method,
• 1617:   if (mState & (XML_HTTP_REQUEST_OPENED |
• 1731:   ChangeState(XML_HTTP_REQUEST_OPENED);
• 1736:  /* void open (in AUTF8String method, in AUTF8String url); */
• 1738:  nsXMLHttpRequest::Open(const nsACString& method, const nsACString& url)
• 1798:   return OpenRequest(method, url, async, user, password);
• 2187:   // We're a multipart request, so we're not done. Reset to opened.
• 2188:   ChangeState(XML_HTTP_REQUEST_OPENED);
• 2245:   // Make sure we've been opened
• 2246:   if (!mChannel || !(XML_HTTP_REQUEST_OPENED & mState)) {
• 2539:   rv = mACGetChannel->AsyncOpen(acProxyListener, nsnull);
• 2543:   rv = mChannel->AsyncOpen(listener, nsnull);
• 2553:   // Now that we've successfully opened the channel, we can change state. Note
• 2554:   // that this needs to come after the AsyncOpen() and rv check, because this
• 2556:   // up doing our AsyncOpen on a null channel if the reentered AsyncOpen fails.
• 2629:   // Check that we haven't already opened the channel. We can't rely on
• 2631:   // still be waiting for mACGetChannel to actually open mChannel
• 2642:   if (!mChannel) // open() initializes mChannel, and open()
• 2711:   } else if (mState & (XML_HTTP_REQUEST_OPENED | XML_HTTP_REQUEST_SENT)) {
• 2979:   // We're uploading if our state is XML_HTTP_REQUEST_OPENED or
• 2981:   PRBool upload = !!((XML_HTTP_REQUEST_OPENED | XML_HTTP_REQUEST_SENT) & mState);
• 3141:   // We're uploading if our state is XML_HTTP_REQUEST_OPENED or
• 3143:   if ((XML_HTTP_REQUEST_OPENED | XML_HTTP_REQUEST_SENT) & mState) {

• 286:   rv = channel->AsyncOpen(loader, aRequest);

• 278:   nsresult rv = mChannel->AsyncOpen(aListener, nsnull);
• 292:   // Note that if AsyncOpen failed that's ok -- the only caller of
• 302:   nsresult rv = mChannel->Open(getter_AddRefs(in));

• 261:   rv = DoOpenContainer(id);
• 300:  mozSanitizingHTMLSerializer::OpenContainer(const nsIParserNode& aNode)
• 305:   return DoOpenContainer(type);
• 343:  mozSanitizingHTMLSerializer::OpenHead()
• 346:   // return OpenContainer(aNode);
• 353:  mozSanitizingHTMLSerializer::DoOpenContainer(PRInt32 aTag)
• 458:   DoOpenContainer(type);

• 108:   NS_IMETHOD OpenContainer(const nsIParserNode& aNode);
• 120:   NS_IMETHOD OpenHead();
• 145:   nsresult DoOpenContainer(PRInt32 aTag);

• 509:  GK_ATOM(loopend, "loopend")
• 676:  GK_ATOM(open, "open")

• 1284:   // docshell in the iframe, and the content sink's call to OpenBody().

• 915:   PRBool lineBreakBeforeOpen = LineBreakBeforeOpen(content->GetNameSpaceID(), name);
• 918:   if (mColPos && lineBreakBeforeOpen) {
• 969:   && !mDoRaw && LineBreakAfterOpen(content->GetNameSpaceID(), name)) {
• 1321:  nsXMLContentSerializer::LineBreakBeforeOpen(PRInt32 aNamespaceID, nsIAtom* aName)
• 1327:  nsXMLContentSerializer::LineBreakAfterOpen(PRInt32 aNamespaceID, nsIAtom* aName)

• 73:   * - mChannel is non-null between asyncOpen and onStopRequest (NOTE: Only needs
• 396:   * Non-null between asyncOpen and onStopRequest.

• 216:   * A simple iterator class for traversing the content in "open tag" order

• 301:   * Returns PR_TRUE if a line break should be inserted before an element open tag
• 303:   virtual PRBool LineBreakBeforeOpen(PRInt32 aNamespaceID, nsIAtom* aName);
• 306:   * Returns PR_TRUE if a line break should be inserted after an element open tag
• 308:   virtual PRBool LineBreakAfterOpen(PRInt32 aNamespaceID, nsIAtom* aName);

• 182:   * If there is an "active" request (that is, if open() or openRequest() has
• 199:   [noscript] void openRequest(in AUTF8String method,
• 208:   * description of <code>openRequest</code>, but the last
• 211:   * If there is an "active" request (that is, if open() or openRequest() has
• 231:   void open(in AUTF8String method, in AUTF8String url);
• 270:   * Sets a HTTP request header for HTTP requests. You must call open
• 282:   * 0 UNINITIALIZED open() has not been called yet.
• 366:   * Call open() before setting an onreadystatechange listener.
• 385:   * This event listener must be set BEFORE calling open().

• 89:   processing any tag (e.g. in OpenContainer or AddLeaf), ask that

• 146:   * Return true if dropmarker is in open state (combobox popup is open),
• 150:   NS_IMETHOD IsDropmarkerOpen(nsIDOMNode *aElement, PRBool* aIsOpen) = 0;
• 153:   * Toggles dropmarker state (close/open combobox popup). Failure if given

• 177:   * When a document's scope changes (e.g., from document.open(), call this
• 1152:   * Notify when the first XUL menu is opened and when the all XUL menus are
• 1153:   * closed. At opening, aInstalling should be TRUE, otherwise, it should be

• 520:   * together; likewise IME_STATUS_OPEN and IME_STATUS_CLOSE must
• 523:   * OPEN or CLOSE flag; that way, when IME is next enabled,
• 524:   * the previous OPEN/CLOSE state will be restored (unless the newly
• 525:   * focused content specifies the OPEN/CLOSE state by setting the OPEN
• 541:   IME_STATUS_OPEN = 0x0010,
• 547:   IME_STATUS_MASK_OPENED = IME_STATUS_OPEN | IME_STATUS_CLOSE

• 1218:   // basically be true only for documents that exist in newly-opened windows or

• 89:   * channel. The channel must be possible to open synchronously.

• 904:   NS_ASSERTION(postDataChunkStream, "Could not open a stream for POST!");

• 3028:   openAllowed : openAbused);

• 132:   // There is no opening parenthesis...

• 2591:   // Open the file
• 2629:   nsIFileInputStream::REOPEN_ON_REWIND);

• 585:   rv = mChannel->AsyncOpen(listener, nsnull);
• 587:   // OnStartRequest is guaranteed to be called if the open succeeds. If
• 588:   // the open failed, the listener's OnStartRequest will never be called,
• 597:   // Else the channel must be open and starting to download. If it encounters
• 866:   || aAttribute == nsGkAtoms::loopend

• 387:   openAllowed : openAbused);

• 502:   mSubmitPopupState(openAbused),
• 989:   mSubmitPopupState = openAbused;

• 350:   // Holds a reference to the first channel we open to the media resource.

• 158:   NS_IMETHOD Open(void);
• 256:   nsresult OpenCommon(const nsACString& aContentType, PRBool aReplace);
• 320:   // eNotWriting. Once document.open has been called (either implicitly or
• 321:   // explicitly), mWriteState will be eDocumentOpened. When document.close has
• 328:   eDocumentOpened,

• 103:   NS_IMETHOD OpenHead();
• 113:   NS_IMETHOD OpenContainer(const nsIParserNode& aNode);
• 325:  nsHTMLFragmentContentSink::OpenHead()
• 389:  nsHTMLFragmentContentSink::OpenContainer(const nsIParserNode& aNode)
• 887:   NS_IMETHOD OpenContainer(const nsIParserNode& aNode);
• 1112:  nsHTMLParanoidFragmentSink::OpenContainer(const nsIParserNode& aNode)
• 1132:   return nsHTMLFragmentContentSink::OpenContainer(aNode);

• 197:   NS_IMETHOD OpenContainer(const nsIParserNode& aNode);
• 210:   NS_IMETHOD OpenHead();
• 253:   PRInt32 mNumOpenIFRAMES;
• 292:   nsresult OpenFrameset(const nsIParserNode& aNode);
• 294:   nsresult OpenBody(const nsIParserNode& aNode);
• 296:   nsresult OpenForm(const nsIParserNode& aNode);
• 307:   nsresult OpenHeadContext();
• 336:   nsresult OpenContainer(const nsIParserNode& aNode);
• 741:  SinkContext::OpenContainer(const nsIParserNode& aNode)
• 746:   "SinkContext::OpenContainer",
• 860:   mSink->mNumOpenIFRAMES++;
• 998:   mSink->mNumOpenIFRAMES--;
• 1686:   // happen when we do document.open()/.write()/.close()...
• 2006:  HTMLContentSink::OpenHead()
• 2008:   MOZ_TIMER_DEBUGLOG(("Start: nsHTMLContentSink::OpenHead()\n"));
• 2011:   nsresult rv = OpenHeadContext();
• 2013:   MOZ_TIMER_DEBUGLOG(("Stop: nsHTMLContentSink::OpenHead()\n"));
• 2020:  HTMLContentSink::OpenBody(const nsIParserNode& aNode)
• 2022:   MOZ_TIMER_DEBUGLOG(("Start: nsHTMLContentSink::OpenBody()\n"));
• 2026:   "HTMLContentSink::OpenBody",
• 2031:   CloseHeadContext(); // do this just in case if the HEAD was left open!
• 2037:   MOZ_TIMER_DEBUGLOG(("Stop: nsHTMLContentSink::OpenBody()\n"));
• 2043:   nsresult rv = mCurrentContext->OpenContainer(aNode);
• 2046:   MOZ_TIMER_DEBUGLOG(("Stop: nsHTMLContentSink::OpenBody()\n"));
• 2056:   MOZ_TIMER_DEBUGLOG(("Stop: nsHTMLContentSink::OpenBody()\n"));
• 2126:  HTMLContentSink::OpenForm(const nsIParserNode& aNode)
• 2128:   MOZ_TIMER_DEBUGLOG(("Start: nsHTMLContentSink::OpenForm()\n"));
• 2136:   "HTMLContentSink::OpenForm",
• 2158:   result = mCurrentContext->OpenContainer(aNode);
• 2161:   MOZ_TIMER_DEBUGLOG(("Stop: nsHTMLContentSink::OpenForm()\n"));
• 2198:  HTMLContentSink::OpenFrameset(const nsIParserNode& aNode)
• 2200:   MOZ_TIMER_DEBUGLOG(("Start: nsHTMLContentSink::OpenFrameset()\n"));
• 2203:   "HTMLContentSink::OpenFrameset",
• 2208:   CloseHeadContext(); // do this just in case if the HEAD was left open!
• 2210:   // Need to keep track of whether OpenContainer changes mFrameset
• 2212:   nsresult rv = mCurrentContext->OpenContainer(aNode);
• 2215:   MOZ_TIMER_DEBUGLOG(("Stop: nsHTMLContentSink::OpenFrameset()\n"));
• 2314:  HTMLContentSink::OpenContainer(const nsIParserNode& aNode)
• 2316:   MOZ_TIMER_DEBUGLOG(("Start: nsHTMLContentSink::OpenContainer()\n"));
• 2323:   rv = OpenFrameset(aNode);
• 2326:   rv = OpenHeadContext();
• 2333:   rv = OpenBody(aNode);
• 2347:   rv = OpenForm(aNode);
• 2350:   rv = mCurrentContext->OpenContainer(aNode);
• 2354:   MOZ_TIMER_DEBUGLOG(("Stop: nsHTMLContentSink::OpenContainer()\n"));
• 2790:  HTMLContentSink::OpenHeadContext()
• 3294:   FILE* out = ::fopen("rtest_html.txt", "a");

• 177:   // When this document is opened in the window/tab of the referring
• 180:   // document is opened in a new window, it is |defaultCharacterSet| of |muCV|
• 181:   // where the charset of our interest is stored. In case of openining
• 201:   if (csAtom) { // opening in a new tab
• 214:   muCV->GetPrevDocCharacterSet(charset); // opening in the same window/tab
• 216:   muCV->GetDefaultCharacterSet(charset); // opening in a new window
• 321:   // This is necessary to deal with a media document being opened in a new

• 282:  nsWyciwygChannel::Open(nsIInputStream ** aReturn)
• 288:  nsWyciwygChannel::AsyncOpen(nsIStreamListener *listener, nsISupports *ctx)
• 291:   // HTMLDocument::OpenCommon and session history. Both should be setting an
• 295:   LOG(("nsWyciwygChannel::AsyncOpen [this=%x]\n", this));
• 304:   // open a cache entry for this channel...
• 306:   nsresult rv = OpenCacheEntry(spec, nsICache::ACCESS_READ, &delayed);
• 318:   LOG(("nsWyciwygChannel::OpenCacheEntry failed [rv=%x]\n", rv));
• 353:   rv = OpenCacheEntry(spec, nsICache::ACCESS_WRITE);
• 369:   rv = mCacheEntry->OpenOutputStream(0, getter_AddRefs(mCacheOutputStream));
• 564:  nsWyciwygChannel::OpenCacheEntry(const nsACString & aCacheKey,
• 585:   // Open a stream based cache session.
• 591:   /* we'll try to synchronously open the cache entry... however, it
• 593:   * asynchronously opening the cache entry.
• 596:   rv = cacheSession->OpenCacheEntry(aCacheKey, aAccessMode, PR_FALSE,
• 600:   // access to the cache entry has been denied. Let's try opening it
• 602:   rv = cacheSession->AsyncOpenCacheEntry(aCacheKey, aAccessMode, this);
• 609:   LOG(("nsWyciwygChannel::OpenCacheEntry got cache entry \n"));
• 627:   rv = mCacheEntry->OpenInputStream(0, getter_AddRefs(mCacheInputStream));

• 85:   nsresult OpenCacheEntry(const nsACString & aCacheKey, nsCacheAccessMode aWriteAccess, PRBool * aDelayFlag = nsnull);

• 962:   // If we're writing (i.e., there's been a document.open call), then
• 1003:   if (!htmldoc->mWriteLevel && htmldoc->mWriteState != eDocumentOpened) {
• 1777:  // XXX TBI: accepting arguments to the open method.
• 1779:  nsHTMLDocument::OpenCommon(const nsACString& aContentType, PRBool aReplace)
• 1782:   // No calling document.open() on XHTML
• 1789:   // If we already have a parser we ignore the document.open call.
• 1818:   // should inherit the security information of the document that's opening us,
• 1824:   // document we can't do a document.open w/o changing the principal of the
• 1872:   // The open occurred after the document finished loading.
• 1909:   // document.open() us, they get a new inner window.
• 1943:   mWriteState = eDocumentOpened;
• 1964:   // Now check whether we were opened with a "replace" argument. If
• 1978:   NS_ASSERTION(!mWyciwygChannel, "nsHTMLDocument::OpenCommon(): wyciwyg "
• 1983:   // knows that document.open/write/close() is being called on this
• 1995:  nsHTMLDocument::Open()
• 1998:   return Open(NS_LITERAL_CSTRING("text/html"), PR_FALSE, getter_AddRefs(doc));
• 2002:  nsHTMLDocument::Open(const nsACString& aContentType, PRBool aReplace,
• 2005:   nsresult rv = OpenCommon(aContentType, aReplace);
• 2029:   if (mParser && mWriteState == eDocumentOpened) {
• 2041:   // nsHTMLDocument::OpenCommon() so that it completely destroys the
• 2065:   // that we added in OpenCommon(). If all other requests between
• 2066:   // document.open() and document.close() have completed, then this
• 2104:   rv = Open();
• 2106:   // If Open() fails, or if it didn't create a parser (as it won't
• 2804:   "write", "writeln", "open", "close", "forms", "elements",

• 52:   * Append data to the cache entry; opens the cache entry if necessary.

• 75:   int openOutput (char * outputFilename)
• 99:   if (mOut && mOut->is_open())

• 121:   PRUint8 i, dropStart, dropEnd;
• 134:   for (dropEnd = kCount - 3 - dropStart; dropEnd > 0; --dropEnd) {
• 135:   expr = exprHead[dropStart] + exprTail[dropEnd];

• 331:   resultFileStream.open(fname.get(), ios::out);
• 336:   resultFileStream.open(argv[argn], ios::out);
• 340:   cerr << "error opening output file" << endl;

• 168:   resultFileStream.open(option->mValues[0].get(), ios::out);
• 170:   cerr << "error opening output file: ";

• 24:   * Larry Fitzpatrick, OpenText <lef@opentext.com>

• 24:   * Larry Fitzpatick, OpenText <lef@opentext.com>

• 50:   * This class was ported from XSL:P, an open source Java based
• 160:   * This class was ported from XSL:P, an open source Java based XSL processor

• 24:   * Larry Fitzpatrick, OpenText <lef@opentext.com>

• 91:   mOpenedElementIsHTML(PR_FALSE),
• 116:   mOpenedElementIsHTML(PR_FALSE),
• 141:   if (mOpenedElementIsHTML && aNsID == kNameSpaceID_None) {
• 164:   if (mOpenedElementIsHTML && aNsID == kNameSpaceID_None) {
• 194:   if (!mOpenedElement) {
• 199:   NS_ASSERTION(!mBadChildLevel, "mBadChildLevel set when element is opened");
• 201:   return mOpenedElement->SetAttr(aNsID, aLocalName, aPrefix, aValue,
• 535:   mOpenedElementIsHTML = PR_FALSE;
• 542:   NS_NewElement(getter_AddRefs(mOpenedElement), aNsID, ni, PR_FALSE);
• 547:   mOpenedElementIsHTML = (mOutputFormat.mMethod == eHTMLOutput);
• 548:   rv = startHTMLElement(mOpenedElement, mOpenedElementIsHTML);
• 554:   nsCOMPtr<nsIScriptElement> sele = do_QueryInterface(mOpenedElement);
• 562:   do_QueryInterface(mOpenedElement);
• 578:   if (mOpenedElement) {
• 593:   rv = mCurrentNode->AppendChildTo(mOpenedElement, PR_TRUE);
• 596:   mCurrentNode = mOpenedElement;
• 597:   mOpenedElement = nsnull;

• 547:   return channel->AsyncOpen(listener, parser);

• 176:   mErrorString.AppendLiteral("unable to parse xml: invalid or unopen stream encountered.");

• 55:   mStartTagOpen(MB_FALSE),
• 69:   if (!mStartTagOpen) {
• 183:   MBool writeEndTag = !(mStartTagOpen && mUseEmptyElementShorthand);
• 258:   MBool newLine = mStartTagOpen || mAfterEndTag;
• 270:   mStartTagOpen = MB_TRUE;
• 293:   if (mStartTagOpen) {
• 312:   mStartTagOpen = MB_FALSE;

• 745:  txStylesheetCompilerState::openInstructionContainer(txInstructionContainer* aContainer)

• 361:   aErr.receiveError(NS_LITERAL_STRING("Couldn't open ") + path);

• 134:   nsresult openInstructionContainer(txInstructionContainer* aContainer);

• 203:   if (!mStartTagOpen)
• 267:   mStartTagOpen) {
• 345:   if (mStartTagOpen && currentElement &&

• 114:   MBool mStartTagOpen;

• 130:   // until then the opened element is
• 131:   // kept in mOpenedElement
• 132:   nsCOMPtr<nsIContent> mOpenedElement;
• 160:   PRPackedBool mOpenedElementIsHTML;

• 560:   aState.openInstructionContainer(templ);
• 669:   aState.openInstructionContainer(attrSet);
• 1156:   aState.openInstructionContainer(templ);
• 1205:   aState.openInstructionContainer(var);

• 465:   // open URI

• 222:   mErrorString.AppendLiteral("unable to parse xml: invalid or unopen stream encountered.");

• 1000:   GenerateDragDropEnterExit(aPresContext, (nsGUIEvent*)aEvent);
• 1560:   // If the toolbar button has an open menu, don't attempt to open
• 1562:   if (mGestureDownContent->AttrValueIs(kNameSpaceID_None, nsGkAtoms::open,
• 2908:   GenerateDragDropEnterExit(presContext, (nsGUIEvent*)aEvent);
• 3503:  nsEventStateManager::GenerateDragDropEnterExit(nsPresContext* aPresContext,

• 209:   if (aState & nsIContent::IME_STATUS_MASK_OPENED) {
• 210:   PRBool open = !!(aState & nsIContent::IME_STATUS_OPEN);
• 211:   aKB->SetIMEOpenState(open);

• 1140:   PopupControlState abuse = openAbused;
• 1151:   abuse = openControlled;
• 1155:   abuse = openControlled;
• 1168:   abuse = openControlled;
• 1181:   abuse = openControlled;
• 1193:   abuse = openAllowed;
• 1195:   abuse = openControlled;
• 1200:   abuse = openAllowed;
• 1202:   abuse = openControlled;
• 1206:   abuse = openControlled;
• 1217:   abuse = openControlled;
• 1221:   abuse = openControlled;
• 1229:   abuse = openAllowed;
• 1233:   abuse = openControlled;
• 1243:   abuse = openControlled;
• 1255:   abuse = openControlled;
• 1259:   abuse = openControlled;
• 1266:   abuse = openControlled;

• 186:   void GenerateDragDropEnterExit(nsPresContext* aPresContext, nsGUIEvent* aEvent);

• 777:   KEYCODE_ENTRY(VK_OPEN_BRACKET),

• 117:   PRBool OnOpenContainer(const PRUnichar **aAtts,

• 1271:   // Open channel
• 1304:   rv = channel->AsyncOpen(xblListener, nsnull);
• 1326:   rv = channel->Open(getter_AddRefs(in));

• 315:   // Check whether we've opened this tag before; we may not have if
• 319:   // OK, this tag was never opened as far as the XML sink is
• 403:  nsXBLContentSink::OnOpenContainer(const PRUnichar **aAtts,

• 104:   NS_ASSERTION(mStreams.IsEmpty(), "Stream(s) still open!");
• 139:   void OpenStream(nsMediaCacheStream* aStream);
• 415:   rv = tmpFile->OpenNSPRFileDesc(PR_RDWR | nsILocalFile::DELETE_ON_CLOSE,
• 973:   // Seek back to 0 (the client will reopen the stream) and then
• 1228:  nsMediaCache::OpenStream(nsMediaCacheStream* aStream)
• 1906:   gMediaCache->OpenStream(this);

• 69:   mReopenOnError(PR_FALSE), mIgnoreClose(PR_FALSE),
• 89:  // listener objects so that when we open a new stream for a seek we can
• 237:   mReopenOnError = PR_FALSE;
• 264:   mReopenOnError) {
• 268:   // If the reopen/reseek fails, just fall through and treat this
• 350:  nsresult nsMediaChannelStream::Open(nsIStreamListener **aStreamListener)
• 360:   return OpenChannel(aStreamListener);
• 363:  nsresult nsMediaChannelStream::OpenChannel(nsIStreamListener** aStreamListener)
• 407:   nsresult rv = mChannel->AsyncOpen(listener, nsnull);
• 549:   // timed out the connection and we should reopen it.
• 550:   mReopenOnError = PR_TRUE;
• 574:   // The decoder is being shut down, so don't bother opening a new channel
• 596:   return OpenChannel(nsnull);
• 733:   virtual nsresult Open(nsIStreamListener** aStreamListener);
• 767:   // The file size, or -1 if not known. Immutable after Open().
• 808:  nsresult nsMediaFileStream::Open(nsIStreamListener** aStreamListener)
• 818:   // The channel is already open. We need a synchronous stream that
• 820:   // file and reopen it
• 842:   rv = mChannel->Open(getter_AddRefs(mInput));
• 850:   // doing an async open and waiting until we locate the real resource,
• 927:  nsMediaStream::Open(nsMediaDecoder* aDecoder, nsIURI* aURI,
• 932:   "nsMediaStream::Open called on non-main thread");
• 962:   nsresult rv = stream->Open(aListener);

• 138:   return nsMediaStream::Open(aDecoder, aURI, aChannel,

• 111:   responsible for creating and opening the stream, and may also cancel it.
• 181:   void OpenAudioStream();
• 252:   // playback thread except for create, open, and cancel, which are called
• 539:   OpenAudioStream();
• 825:  nsWaveStateMachine::OpenAudioStream()
• 1296:   // Open the stream *after* setting mPlaybackStateMachine, to ensure
• 1298:   nsresult rv = nsMediaStream::Open(this, mURI, aChannel, getter_Transfers(mStream),

• 396:   // Initializes and opens the audio stream. Called from the decode
• 398:   void OpenAudioStream();
• 405:   // Start playback of audio, either by opening or resuming the audio
• 414:   // This opens or re-opens the audio stream for playback to start.
• 883:   // If we are playing we open the audio stream if needed
• 1018:  void nsOggDecodeStateMachine::OpenAudioStream()
• 1020:   // NS_ASSERTION(PR_InMonitor(mDecoder->GetMonitor()), "OpenAudioStream() called without acquiring decoder monitor");
• 1044:   OpenAudioStream();
• 1765:   mPlayer = oggplay_open_with_reader(aReader);

• 96:   if (sa_stream_open(static_cast<sa_stream_t*>(mAudioHandle)) != SA_SUCCESS) {
• 99:   PR_LOG(gAudioStreamLog, PR_LOG_ERROR, ("nsAudioStream: sa_stream_open error"));
• 187:   // If the audio backend failed to open, lie and say we'll accept some

• 129:   Provides the ability to open, read and seek into a media stream
• 256:   static nsresult Open(nsMediaDecoder* aDecoder, nsIURI* aURI,
• 271:   * @param aStreamListener if null, the strategy should open mChannel
• 272:   * itself. Otherwise, mChannel is already open and the strategy
• 276:   virtual nsresult Open(nsIStreamListener** aStreamListener) = 0;
• 287:   // URI in case the stream needs to be re-opened. Access from
• 323:   virtual nsresult Open(nsIStreamListener** aStreamListener);
• 377:   // Opens the channel, using an HTTP byte range request to start at mOffset
• 379:   nsresult OpenChannel(nsIStreamListener** aStreamListener);
• 396:   // reopen the stream.
• 397:   PRPackedBool mReopenOnError;

• 51:   * high latency to open a connection, requires a new connection for every
• 179:   * Streams can be opened in non-seekable mode. In non-seekable mode,

• 270:   // When we aren't grabbing all of the content we, never open a doc

• 127:   virtual PRBool OnOpenContainer(const PRUnichar **aAtts,

• 436:   rv = channel->AsyncOpen(listener, nsnull);

• 107:  // XXX Open Issues:
• 1064:   if (!OnOpenContainer(aAtts, aAttsCount, nameSpaceID, localName, aLineNumber)) {
• 1183:   // XXXbz for roots that don't want to be appended on open, we
• 1184:   // probably need to deal here.... (and stop appending them on open).

• 75:   FILE* input = fopen(input_name, "rb");
• 101:   printf("%s: can't open file `%s'\n", argv[0], input_name);
• 122:   FILE* output = fopen(argv[2], "wb");
• 124:   printf("%s: can't open file `%s'\n", argv[0], argv[2]);

• 4:  Copyright (c) 1993, 1994, 1998 The Open Group.
• 18:  OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
• 22:  Except as contained in this notice, the name of The Open Group shall not be
• 24:  in this Software without prior written authorization from The Open Group.

• 238:  #if defined(__386BSD__) || defined(__NetBSD__) || defined(__FreeBSD__) || defined(__OpenBSD__)
• 276:  #if defined(__386BSD__) || defined(__NetBSD__) || defined(__FreeBSD__) || defined(__OpenBSD__) || defined(MACH)
• 722:  #ifdef __OpenBSD__
• 723:   {"__OpenBSD__", "1"},

• 52:  // freopen won't work on stdout in win16
• 65:   if (OpenFile(lpszFileIn, &of, OF_PARSE) != HFILE_ERROR)
• 153:   // open the file and grab all the includes.
• 175:   f = fopen(m_pathName, "r");
• 721:   if( f.Open( pStr, CFile::modeRead ) ){
• 754:   if(!(pAltFile = fopen(pStr, "w+"))) {
• 799:   if( f.Open( &argv[i][1], CFile::modeRead ) ){

• 133:   PRBool mDialogOpen;

• 208:   // On the other hand the user might be opening a non-http XPI link

• 108:   mContentLength(0), mDialogOpen(PR_FALSE), mCancelled(PR_FALSE),
• 189:   nsresult rv = Observe(aListener, XPI_PROGRESS_TOPIC, NS_LITERAL_STRING("open").get());
• 259:   rv = NS_OpenURI(listener, nsnull, uri, nsnull, mLoadGroup);
• 335:   // Open the progress dialog
• 338:   rv = dlgSvc->OpenProgressDialog( packageList, numStrings, this );
• 397:   rv = parentWindow->OpenDialog(NS_ConvertASCIItoUTF16(confirmDialogURL),
• 476:  nsXPInstallManager::OpenProgressDialog(const PRUnichar **aPackageList, PRUint32 aCount, nsIObserver *aObserver)
• 504:   // --- open the window
• 540:   rv = wwatch->OpenWindow(0,
• 569:   if ( data.Equals( NS_LITERAL_STRING("open") ) )
• 571:   // -- The dialog has been opened
• 572:   if (mDialogOpen)
• 573:   return NS_OK; // We've already been opened, nothing more to do
• 575:   mDialogOpen = PR_TRUE;
• 595:   if ( !mDialogOpen )
• 597:   // if we've never been opened then we can shutdown right here,
• 695:  // Function name : OpenAndValidateArchive
• 696:  // Description : Opens install archive and validates contents
• 705:  OpenAndValidateArchive(nsIZipReader* hZip, nsIFile* jarFile, nsIPrincipal* aPrincipal)
• 713:   rv = hZip->Open(jFile);
• 789:   PRInt32 finalStatus = OpenAndValidateArchive( hZip,
• 845:   // Already local, we can open it where it is
• 901:   rv = channel->AsyncOpen(this, nsnull);
• 1397:   nsresult rv = NS_OpenURI(listener, nsnull, uri, nsnull, mLoadGroup);
• 1399:   NS_ASSERTION(NS_SUCCEEDED(rv), "OpenURI failed");

• 87:   * @brief Create and open a download-and-install progress dialog
• 89:   * When called the XPIDialogService implementation creates and opens
• 93:   * the dialog, the topic is "xpinstall-progress" and the data is "open".
• 106:   void openProgressDialog([array, size_is(count)] in wstring packageList,

• 68:   * openProgressDialog. ignored when state==DIALOG_CLOSE

• 194:   rv = mChannel->AsyncOpen(this, nsnull);
• 335:  nsOfflineCacheUpdateItem::OpenChannel()
• 341:   LOG(("%p: Opening channel for %s", this, spec.get()));
• 388:   rv = mChannel->AsyncOpen(this, nsnull);
• 1512:   nsresult rv = mManifestItem->OpenChannel();
• 1621:   LOG(("%p: Opening channel for %s", this, spec.get()));
• 1627:   nsresult rv = mItems[mCurrentItem]->OpenChannel();

• 210:  nsPrefetchNode::OpenChannel()
• 230:   rv = mChannel->AsyncOpen(this, nsnull);
• 479:   // if opening the channel fails, then just skip to the next uri
• 481:   rv = mCurrentNode->OpenChannel();

• 103:   nsresult OpenChannel();

• 138:   nsresult OpenChannel();

• 67:   * parented when opened.

• 388:   if (noErr != FSpOpenRF(&m_fsFileSpec, fsWrPerm, &m_rfRefNum))

• 59:   static NS_HIDDEN_(nsresult) OpenApplicationWithURI(nsIFile *aApplication,

• 81:   * application in response to a link click or a X-remote openURL command.
• 144:   * may be ultimately passed nsIURILoader.openURI in the case of a

• 132:   * @param aFile The file that should be opened
• 184:   * open as first argument.

• 324:   * was opened specifically for this download. If so, then we
• 406:   nsresult OpenWithApplication();
• 410:   * and calls either MoveFile or OpenWithApplication

• 289:   static const PRUnichar cmdVerb[] = L"open";
• 377:   nsresult rv = appKey->Open(nsIWindowsRegKey::ROOT_KEY_CLASSES_ROOT,
• 383:   // Check for the NoOpenWith flag, if it exists
• 386:   NS_LITERAL_STRING("NoOpenWith"), &value)) &&
• 392:   NS_LITERAL_STRING("NoOpenWith"), dummy)))
• 397:   // HKEY_CLASSES_ROOT\Applications\iexplore.exe\shell\open\command
• 401:   applicationsPath.AppendLiteral("\\shell\\open\\command");
• 406:   rv = appKey->Open(nsIWindowsRegKey::ROOT_KEY_CLASSES_ROOT,
• 429:  // (dll, targetfile, return args, open/edit)
• 455:   nsresult rv = appKey->Open(nsIWindowsRegKey::ROOT_KEY_CLASSES_ROOT,
• 461:   // Check for the NoOpenWith flag, if it exists
• 463:   rv = appKey->ReadIntValue(NS_LITERAL_STRING("NoOpenWith"), &value);
• 468:   if (NS_SUCCEEDED(appKey->ReadStringValue(NS_LITERAL_STRING("NoOpenWith"),
• 474:   // HKEY_CLASSES_ROOT\Applications\iexplore.exe\shell\open\command
• 478:   applicationsPath.AppendLiteral("\\shell\\open\\command");
• 482:   rv = appKey->Open(nsIWindowsRegKey::ROOT_KEY_CLASSES_ROOT,
• 550:   // HKEY_CLASSES_ROOT\Windows.XPSReachViewer\shell\open\command
• 552:   appProgId.AppendLiteral("\\shell\\open\\command");
• 556:   nsresult rv = appKey->Open(nsIWindowsRegKey::ROOT_KEY_CLASSES_ROOT,
• 623:   * best list. Typically used for an "open with" style user
• 671:   rv = regKey->Open(nsIWindowsRegKey::ROOT_KEY_CLASSES_ROOT,
• 696:   rv = regKey->Open(nsIWindowsRegKey::ROOT_KEY_CLASSES_ROOT,
• 717:   // 2) list HKEY_CLASSES_ROOT\.ext\OpenWithList\
• 720:   workingRegistryPath.AppendLiteral("\\OpenWithList");
• 722:   rv = regKey->Open(nsIWindowsRegKey::ROOT_KEY_CLASSES_ROOT,
• 747:   // 3) List HKEY_CLASSES_ROOT\.ext\OpenWithProgids, with the
• 751:   workingRegistryPath.AppendLiteral("\\OpenWithProgids");
• 753:   rv = regKey->Open(nsIWindowsRegKey::ROOT_KEY_CLASSES_ROOT,
• 760:   // HKEY_CLASSES_ROOT\.ext\OpenWithProgids\Windows.XPSReachViewer
• 781:   // Explorer\FileExts\.ext\OpenWithList
• 785:   workingRegistryPath.AppendLiteral("\\OpenWithList");
• 787:   rv = regKey->Open(nsIWindowsRegKey::ROOT_KEY_CURRENT_USER,
• 819:   // Explorer\FileExts\.ext\OpenWithProgids
• 823:   workingRegistryPath.AppendLiteral("\\OpenWithProgids");
• 825:   regKey->Open(nsIWindowsRegKey::ROOT_KEY_CURRENT_USER,
• 850:   // open with list.
• 855:   regKey->Open(nsIWindowsRegKey::ROOT_KEY_CLASSES_ROOT,
• 863:   nsAutoString openWithListPath(NS_LITERAL_STRING("SystemFileAssociations\\"));
• 864:   openWithListPath.Append(perceivedType); // no period
• 865:   openWithListPath.Append(NS_LITERAL_STRING("\\OpenWithList"));
• 867:   nsresult rv = appKey->Open(nsIWindowsRegKey::ROOT_KEY_CLASSES_ROOT,
• 868:   openWithListPath,
• 893:   // 7) list global HKEY_CLASSES_ROOT\*\OpenWithList\
• 896:   workingRegistryPath = NS_LITERAL_STRING("*\\OpenWithList");
• 898:   rv = regKey->Open(nsIWindowsRegKey::ROOT_KEY_CLASSES_ROOT,
• 925:   rv = regKey->Open(nsIWindowsRegKey::ROOT_KEY_CLASSES_ROOT,

• 107:   nsresult rv = regKey->Open(nsIWindowsRegKey::ROOT_KEY_CLASSES_ROOT,
• 130:   Open(nsIWindowsRegKey::ROOT_KEY_CURRENT_USER,
• 180:   LONG err = ::RegOpenKeyExW(HKEY_CLASSES_ROOT,
• 232:   buf.AppendLiteral("\\shell\\open\\command");
• 233:   nsresult rv = regKey->Open(nsIWindowsRegKey::ROOT_KEY_CLASSES_ROOT,
• 263:   rv = regKey->Open(nsIWindowsRegKey::ROOT_KEY_CLASSES_ROOT,
• 300:   nsresult rv = regKey->Open(nsIWindowsRegKey::ROOT_KEY_CLASSES_ROOT,
• 444:   // Applications\appfile.exe/dll (shell\open...)
• 445:   // ProgID.progid (shell\open...)
• 454:   nsresult rv = chkKey->Open(nsIWindowsRegKey::ROOT_KEY_CLASSES_ROOT,
• 462:   handlerKeyName.AppendLiteral("\\shell\\open\\command");
• 468:   nsresult rv = regKey->Open(nsIWindowsRegKey::ROOT_KEY_CLASSES_ROOT,
• 525:   nsresult rv = regKey->Open(nsIWindowsRegKey::ROOT_KEY_CLASSES_ROOT,

• 54:   * in order to cause a "save to disk" or "open using" action.

• 155:  static const char NEVER_ASK_FOR_OPEN_FILE_PREF[] = "openFile";
• 320:   // XXXbz this code is duplicated in nsDocumentOpenInfo::DispatchContent.
• 321:   // Factor it out! Maybe store it in the nsDocumentOpenInfo?
• 1421:   // Determine whether a new window was opened specifically for this request
• 1467:   // and it was opened specifically for the download
• 1513:   // honor it only if the default action is "save". Opening attachments in
• 1515:   // is one part of a multipart document). Opening sniffed content in helper
• 1545:   else if (!GetNeverAskFlagFromPref(NEVER_ASK_FOR_OPEN_FILE_PREF, MIMEType.get()))
• 1591:   // We need to do the save/open immediately, then.
• 1594:   * executable. If it could, we had better not try to open it!
• 1595:   * We can skip this check, though, if we have a setting to open in a
• 1877:   rv = OpenWithApplication();
• 1950:   // we are back from the helper app dialog (where the user chooses to save or open), but we aren't
• 2136:   if (NS_FAILED(rv)) { // (Re-)opening the output stream failed. bad luck.
• 2161:  nsresult nsExternalAppHandler::OpenWithApplication()
• 2374:   // Reset the window context to the opener window so that the dependent
• 2376:   nsCOMPtr<nsIDOMWindowInternal> opener;
• 2377:   internalWindow->GetOpener(getter_AddRefs(opener));
• 2380:   if (opener && NS_SUCCEEDED(opener->GetClosed(&isClosed)) && !isClosed) {
• 2381:   mWindowContext = do_GetInterface(opener);
• 2384:   // into issues trying to close the window before it has fully opened.

• 14:   FILE* outfile = fopen(value, "w");

• 63:  // a stub channel implemenation which will map calls to AsyncRead and OpenInputStream
• 80:   nsresult OpenURL();
• 87:   PRBool mWasOpened;
• 103:   mWasOpened(PR_FALSE)
• 167:  nsresult nsExtProtocolChannel::OpenURL()
• 203:  NS_IMETHODIMP nsExtProtocolChannel::Open(nsIInputStream **_retval)
• 205:   return OpenURL();
• 208:  NS_IMETHODIMP nsExtProtocolChannel::AsyncOpen(nsIStreamListener *listener, nsISupports *ctxt)
• 211:   NS_ENSURE_TRUE(!mWasOpened, NS_ERROR_ALREADY_OPENED);
• 213:   mWasOpened = PR_TRUE;
• 215:   return OpenURL();

• 132:  // opens a file using the selected program or WPS object
• 155:   // if there's no program, use the WPS to open the file
• 160:   // the app associated with this file; if so, use it to open the file;
• 171:   rv = rwsSvc->OpenWithAppHandle(filePath.get(), appHandle);
• 176:   // if RWS isn't present or fails, open it using a PM call
• 178:   if (WinSetObjectData(WinQueryObject(filePath.get()), "OPEN=DEFAULT"))
• 185:   // open the data file using the specified program file
• 204:   // if RWS is enabled, have the WPS open the file using the selected app;
• 212:   rv = rwsSvc->OpenWithAppPath(filePath.get(), appPath.get());

• 369:  /* Open the file, read the first line, decide what type of file it is,
• 539:  /* Open the file, read the first line, decide what type of file it is,

• 363:  /* Open the file, read the first line, decide what type of file it is,
• 532:  /* Open the file, read the first line, decide what type of file it is,

• 64:   if (hildon_uri_open(spec.get(), action, nsnull))
• 127:   * mime/file via hildon specific APIs (in this case hildon_mime_open_file*
• 128:   * which are essetially wrappers to the DBUS mime_open method).
• 148:   result = hildon_mime_open_file_with_mime_type(connection,
• 152:   if (hildon_mime_open_file(connection, aFilePath) != kHILDON_SUCCESS)

• 92:   * The nsDocumentOpenInfo contains the state required when a single
• 93:   * document is being opened in order to discover the content type...
• 97:  class nsDocumentOpenInfo : public nsIStreamListener
• 101:   nsDocumentOpenInfo();
• 105:   nsDocumentOpenInfo(nsIInterfaceRequestor* aWindowContext,
• 146:   ~nsDocumentOpenInfo();
• 187:  NS_IMPL_THREADSAFE_ADDREF(nsDocumentOpenInfo)
• 188:  NS_IMPL_THREADSAFE_RELEASE(nsDocumentOpenInfo)
• 190:  NS_INTERFACE_MAP_BEGIN(nsDocumentOpenInfo)
• 196:  nsDocumentOpenInfo::nsDocumentOpenInfo()
• 201:  nsDocumentOpenInfo::nsDocumentOpenInfo(nsIInterfaceRequestor* aWindowContext,
• 210:  nsDocumentOpenInfo::~nsDocumentOpenInfo()
• 214:  nsresult nsDocumentOpenInfo::Prepare()
• 216:   LOG(("[0x%p] nsDocumentOpenInfo::Prepare", this));
• 225:  NS_IMETHODIMP nsDocumentOpenInfo::OnStartRequest(nsIRequest *request, nsISupports * aCtxt)
• 227:   LOG(("[0x%p] nsDocumentOpenInfo::OnStartRequest", this));
• 297:  NS_IMETHODIMP nsDocumentOpenInfo::OnDataAvailable(nsIRequest *request, nsISupports * aCtxt,
• 310:  NS_IMETHODIMP nsDocumentOpenInfo::OnStopRequest(nsIRequest *request, nsISupports *aCtxt,
• 313:   LOG(("[0x%p] nsDocumentOpenInfo::OnStopRequest", this));
• 333:  nsresult nsDocumentOpenInfo::DispatchContent(nsIRequest *request, nsISupports * aCtxt)
• 335:   LOG(("[0x%p] nsDocumentOpenInfo::DispatchContent for type '%s'", this, mContentType.get()));
• 549:   // and let the downstream nsDocumentOpenInfo handle things.
• 611:  nsDocumentOpenInfo::ConvertData(nsIRequest *request,
• 616:   LOG(("[0x%p] nsDocumentOpenInfo::ConvertData from '%s' to '%s'", this,
• 631:   // intermediate nsDocumentOpenInfo instance to handle the targeting of
• 638:   nsCOMPtr<nsDocumentOpenInfo> nextLink =
• 639:   new nsDocumentOpenInfo(m_originalContext, mFlags, mURILoader);
• 642:   LOG((" Downstream DocumentOpenInfo would be: 0x%p", nextLink.get()));
• 669:  nsDocumentOpenInfo::TryContentListener(nsIURIContentListener* aListener,
• 672:   LOG(("[0x%p] nsDocumentOpenInfo::TryContentListener; mFlags = 0x%x",
• 810:  NS_IMETHODIMP nsURILoader::OpenURI(nsIChannel *channel,
• 822:   LOG(("nsURILoader::OpenURI for %s", spec.get()));
• 827:   nsresult rv = OpenChannel(channel,
• 840:   rv = channel->AsyncOpen(loader, nsnull);
• 854:  nsresult nsURILoader::OpenChannel(nsIChannel* channel,
• 857:   PRBool aChannelIsOpen,
• 860:   NS_ASSERTION(channel, "Trying to open a null channel!");
• 869:   LOG(("nsURILoader::OpenChannel for %s", spec.get()));
• 873:   // Let the window context's uriListener know that the open is starting. This
• 881:   winContextListener->OnStartURIOpen(uri, &doAbort);
• 884:   LOG((" OnStartURIOpen aborted load"));
• 890:   // we need to create a DocumentOpenInfo object which will go ahead and open
• 892:   nsCOMPtr<nsDocumentOpenInfo> loader =
• 893:   new nsDocumentOpenInfo(aWindowContext, aFlags, this);
• 929:   if (aChannelIsOpen && !SameCOMIdentity(oldGroup, loadGroup)) {
• 949:  NS_IMETHODIMP nsURILoader::OpenChannel(nsIChannel* channel,
• 959:   return OpenChannel(channel, aFlags, aWindowContext, pending, aListener);

• 56:  class nsDocumentOpenInfo;
• 69:   * Equivalent to nsIURILoader::openChannel, but allows specifying whether the
• 70:   * channel is opened already.
• 72:   NS_HIDDEN_(nsresult) OpenChannel(nsIChannel* channel,
• 75:   PRBool aChannelOpen,
• 92:   friend class nsDocumentOpenInfo;

• 60:   * @param aURI URI that is being opened.
• 63:   * <code>true</code> if the open should be aborted.
• 65:   boolean onStartURIOpen(in nsIURI aURI);

• 52:   * the content and routing the opened url to the correct content
• 55:   * When you encounter a url you want to open, you typically call
• 56:   * openURI, passing it the content listener for the window the uri is
• 57:   * originating from. The uri dispatcher opens the url to discover the
• 74:   * @name Flags for opening URIs.
• 108:   * OpenURI requires the following parameters.....
• 110:   * The channel that should be opened. This must not be asyncOpen'd yet!
• 124:   void openURI(in nsIChannel aChannel,
• 129:   * Loads data from a channel. This differs from openURI in that the channel
• 130:   * may already be opened, and that it returns a stream listener into which the
• 131:   * caller should pump data. The caller is responsible for opening the channel
• 138:   * (e.g. in nsIURIContentListener::onStartURIOpen), this method will return
• 140:   * cancel the channel if it's already open (this method will not cancel the
• 150:   * opened. It must not be closed (i.e. this must be called before the
• 163:   nsIStreamListener openChannel(in nsIChannel aChannel,

• 101:   PRBool DropmarkerOpen(PRBool aToggleOpen);

• 301:   PRBool isOpen;
• 302:   element->HasAttribute(NS_LITERAL_STRING("open"), &isOpen);
• 303:   if (isOpen) {
• 632:   element->HasAttribute(NS_LITERAL_STRING("open"), &isActive);

• 230:  PRBool nsXULDropmarkerAccessible::DropmarkerOpen(PRBool aToggleOpen)
• 232:   PRBool isOpen = PR_FALSE;
• 239:   parentButtonElement->GetOpen(&isOpen);
• 240:   if (aToggleOpen)
• 241:   parentButtonElement->SetOpen(!isOpen);
• 246:   parentMenuListElement->GetOpen(&isOpen);
• 247:   if (aToggleOpen)
• 248:   parentMenuListElement->SetOpen(!isOpen);
• 252:   return isOpen;
• 261:   if (DropmarkerOpen(PR_FALSE))
• 264:   aName.AssignLiteral("open");
• 277:   DropmarkerOpen(PR_TRUE); // Reverse the open attribute
• 309:   if (DropmarkerOpen(PR_FALSE))

• 1056:   PRBool isOpen;
• 1057:   menuList->GetOpen(&isOpen);
• 1058:   if (isOpen) {
• 1151:   menuList->GetOpen(&isDroppedDown);
• 1152:   return menuList->SetOpen(!isDroppedDown);
• 1157:   * if we are closed -> open is our name.
• 1158:   * if we are open -> closed is our name.
• 1172:   menuList->GetOpen(&isDroppedDown);
• 1176:   aName.AssignLiteral("open");

• 884:   PRBool isContainerOpen;
• 885:   mTreeView->IsContainerOpen(mRow, &isContainerOpen);
• 886:   *aState |= isContainerOpen? PRUint32(nsIAccessibleStates::STATE_EXPANDED):
• 1000:   PRBool isContainerOpen;
• 1001:   mTreeView->IsContainerOpen(mRow, &isContainerOpen);
• 1002:   if (isContainerOpen)
• 1207:   return mTreeView->ToggleOpenState(mRow);

• 575:   PRBool isOpen = PR_FALSE;
• 576:   rv = sXFormsService->IsDropmarkerOpen(mDOMNode, &isOpen);
• 579:   if (isOpen)

• 73:   PRBool isOpen = PR_FALSE;
• 74:   nsresult rv = sXFormsService->IsDropmarkerOpen(mDOMNode, &isOpen);
• 77:   if (isOpen)
• 99:   PRBool isOpen = PR_FALSE;
• 100:   nsresult rv = sXFormsService->IsDropmarkerOpen(mDOMNode, &isOpen);
• 103:   if (isOpen)
• 106:   aName.AssignLiteral("open");
• 161:   PRBool isOpen = PR_FALSE;
• 162:   rv = sXFormsService->IsDropmarkerOpen(mDOMNode, &isOpen);
• 167:   if (isOpen)

• 778:   nsCOMPtr<nsISimpleEnumerator> propEnum;
• 779:   nsresult rv = aAttributes->Enumerate(getter_AddRefs(propEnum));
• 783:   while (NS_SUCCEEDED(propEnum->HasMoreElements(&hasMore)) && hasMore) {
• 785:   rv = propEnum->GetNext(getter_AddRefs(sup));

• 86:   EVENT_SYSTEM_DRAGDROPEND, // nsIAccessibleEvent::EVENT_DRAGDROP_END

• 159:   // open the dll dynamically
• 1783:   nsCOMPtr<nsISimpleEnumerator> propEnum;
• 1784:   aAttributes->Enumerate(getter_AddRefs(propEnum));
• 1785:   if (!propEnum)
• 1793:   while (NS_SUCCEEDED(propEnum->HasMoreElements(&hasMore)) && hasMore) {
• 1795:   propEnum->GetNext(getter_AddRefs(propSupports));

• 146:   eOpenCloseAction,
• 322:   // any action, but menu can be open or close.

• 62:   eOpenCloseAction,

• 2346:   case eOpenCloseAction:
• 2348:   aName.AssignLiteral("open");
• 2799:   * When "Click" is to open a "modal" dialog/window, it won't return untill the

• 295:   // add ourself as a OpenStateChange listener (custom event fired in tree.xml)
• 296:   "OpenStateChange",
• 749:   if (treeItemAccessible && eventType.EqualsLiteral("OpenStateChange")) {
• 808:   // when the list is open, based on DOMMenuitemActive events

• 236:   //get the long description uri and open in a new window
• 250:   return win->Open(longDesc, NS_LITERAL_STRING(""), NS_LITERAL_STRING(""),

• 107:   * Used by GetActionName and DoAction to ensure the index for opening the
• 109:   * It is always assumed that the highest possible index opens the longdesc.

• 727:   // If combo box, and open, close it
• 1165:   * if we are closed -> open is our name.
• 1166:   * if we are open -> closed is our name.
• 1185:   aName.AssignLiteral("open");
• 1303:   * if we are closed -> open is our name.
• 1304:   * if we are open -> closed is our name.
• 1318:   aName.AssignLiteral("open");

• 137:   * action, such as Ctrl+O for Open file

• 50:   Open Issues ------------------
• 217:   nsresult OpenRDF(const PRUnichar* aName);
• 218:   nsresult OpenObject(const PRUnichar* aName ,const PRUnichar** aAttributes);
• 219:   nsresult OpenProperty(const PRUnichar* aName, const PRUnichar** aAttributes);
• 220:   nsresult OpenMember(const PRUnichar* aName, const PRUnichar** aAttributes);
• 221:   nsresult OpenValue(const PRUnichar* aName, const PRUnichar** aAttributes);
• 473:   rv = OpenRDF(aName);
• 477:   rv = OpenObject(aName,aAtts);
• 481:   rv = OpenProperty(aName,aAtts);
• 485:   rv = OpenMember(aName,aAtts);
• 490:   rv = OpenValue(aName,aAtts);
• 1107:  RDFContentSinkImpl::OpenRDF(const PRUnichar* aName)
• 1110:   // opening tag is <rdf:RDF>, where "rdf:" corresponds to whatever
• 1130:  RDFContentSinkImpl::OpenObject(const PRUnichar* aName,
• 1207:  RDFContentSinkImpl::OpenProperty(const PRUnichar* aName, const PRUnichar** aAttributes)
• 1283:  RDFContentSinkImpl::OpenMember(const PRUnichar* aName,
• 1287:   // sure that the opening tag is <rdf:li>, where "rdf:" corresponds
• 1339:  RDFContentSinkImpl::OpenValue(const PRUnichar* aName, const PRUnichar** aAttributes)
• 1343:   return OpenObject(aName,aAttributes);

• 68:  static const char kRDFDescriptionOpen[] = " <RDF:Description";
• 617:   // Emit an open tag and the subject
• 626:   rv = rdf_BlockingWrite(aStream, kRDFDescriptionOpen,
• 627:   sizeof(kRDFDescriptionOpen) - 1);
• 772:  static const char kRDFLIOpen[] = " <RDF:li";
• 773:   nsresult rv = rdf_BlockingWrite(aStream, kRDFLIOpen,
• 774:   sizeof(kRDFLIOpen) - 1);
• 798:  static const char kRDFLIOpenGT[] = ">";
• 800:   rv = rdf_BlockingWrite(aStream, kRDFLIOpenGT,
• 801:   sizeof(kRDFLIOpenGT) - 1);
• 864:   // appropriate tag-open sequence

• 57:   surprising behavior.) Eventually, it'd be great if we could open
• 523:   rv = channel->Open(getter_AddRefs(in));
• 980:   rv = NS_OpenURI(this, nsnull, mURL, nsnull, nsnull, this);

• 288:   NS_ASSERTION(NS_SUCCEEDED(rv), "unable to open datasource");

• 1346:   rv = aManifest->OpenNSPRFileDesc(PR_RDONLY, 0, &fd);

• 85:   void open();

• 72:   ldptr = ldopen(fileName, NULL);
• 74:   fprintf(stderr, "%s: unable to open \"%s\"\n", applicationName,

• 73:   l->open();
• 242:   int fd = ::open(M_MAPFILE, O_RDONLY);
• 244:   perror("open: " M_MAPFILE);
• 266:  void leaky::open()
• 272:   // open up the log file
• 273:   mappedLogFile = ::open(logFile, O_RDONLY);
• 275:   perror("open");

• 50:   int fd = ::open(fileName, O_RDONLY);
• 52:   fprintf(stderr, "%s: unable to open \"%s\"\n", applicationName,

• 142:   int mfd = open(M_MAPFILE, O_CREAT|O_WRONLY|O_TRUNC, 0666);
• 217:   /* global */ rtcFD = open("/dev/rtc", O_RDONLY);
• 219:   perror("JPROF_RTC setup: open(\"/dev/rtc\", O_RDONLY)");
• 411:   gLogFD = open(M_LOGFILE, O_CREAT | O_WRONLY | append, 0666);
• 449:   // later be reopened).

• 53:   int fd = open(filename, O_RDONLY);
• 73:   bfd *object = bfd_openr(filename, NULL);
• 168:   bfd* lib = bfd_openr(aFileName, NULL);

• 67:   FILE *in = fopen(aFileName, "r");

• 185:   * Return the old fd, so the caller can swap open fds. Return -2 on failure,

• 189:   * Return -1 on permanent fatal error, 0 if filename can't be opened or is not

• 289:   int fd = open(name, O_RDWR);

• 240:   // Open the perflib key to find out the last counter's index and
• 243:   result = ::RegOpenKeyEx(HKEY_LOCAL_MACHINE,
• 286:   result = ::RegOpenKeyEx(HKEY_LOCAL_MACHINE,

• 79:   display = XOpenDisplay(0);

• 8:   gLogFile = fopen(fileName, "w+b");

• 87:   PRDir *dir = PR_OpenDir(modulesDir);

• 642:   int fd = open(argv[optind], O_RDONLY);

• 117:   int fd = open(argv[optind], O_RDONLY);

• 376:   int fd = open(argv[optind], O_RDONLY);

• 52:   // Open the file readonly.
• 53:   m_fd = open(name, O_RDONLY);

• 148:   int fd = open(argv[optind], O_RDONLY);

• 107:   void open();

• 130:   int mfd = open("malloc-map", O_CREAT|O_WRONLY|O_TRUNC, 0666);
• 340:   gLogFD = open("malloc-log", O_CREAT|O_WRONLY|O_TRUNC, 0666);

• 72:   ldptr = ldopen(fileName, NULL);
• 74:   fprintf(stderr, "%s: unable to open \"%s\"\n", applicationName,

• 73:   l->open();
• 233:   int fd = ::open("malloc-map", O_RDONLY);
• 235:   perror("open: malloc-map");
• 257:  void leaky::open()
• 263:   // open up the log file
• 264:   mappedLogFile = ::open(logFile, O_RDONLY);
• 266:   perror("open");
• 700:   aIndent > 1 ? "close" : "open");

• 51:   int fd = ::open(fileName, O_RDONLY);
• 53:   fprintf(stderr, "%s: unable to open \"%s\"\n", applicationName,

• 58:   void* h = dlopen("/usr/X11R6/lib/libX11.so", RTLD_LAZY);

• 58:   bfd* lib = bfd_openr(aFileName, NULL);

• 5622:   logfp = fopen("/tmp/scope.stats", "a");

• 14:   * The Original Code is [Open Source Virtual Machine].

• 15:   * The Original Code is [Open Source Virtual Machine].

• 15:   * The Original Code is [Open Source Virtual Machine].

• 14:   * The Original Code is [Open Source Virtual Machine].
• 183:   this->_fstream = fopen(outputFileName, "w");

• 15:   * The Original Code is [Open Source Virtual Machine].

• 15:   * The Original Code is [Open Source Virtual Machine].
• 1492:   // SP since we will target fragEntry and not loopEntry.

• 15:   * The Original Code is [Open Source Virtual Machine].
• 2014:   root->loopEntry = 0;
• 2060:   root->loopEntry = 0;

• 15:   * The Original Code is [Open Source Virtual Machine].

• 15:   * The Original Code is [Open Source Virtual Machine].

• 15:   * The Original Code is [Open Source Virtual Machine].

• 12:   * The Original Code is [Open Source Virtual Machine.]
• 686:   // we have 2 cases, either closing a gap or opening it.

• 15:   * The Original Code is [Open Source Virtual Machine].
• 758:   // SP since we will target fragEntry and not loopEntry.

• 12:   * The Original Code is [Open Source Virtual Machine.]

• 15:   * The Original Code is [Open Source Virtual Machine].
• 789:   frag->loopEntry = _nIns;
• 825:   SOT = frag->loopEntry;

• 15:   * The Original Code is [Open Source Virtual Machine].
• 531:   loopEntry(NULL),

• 15:   * The Original Code is [Open Source Virtual Machine].

• 15:   * The Original Code is [Open Source Virtual Machine].

• 15:   * The Original Code is [Open Source Virtual Machine].
• 226:   NIns* loopEntry;

• 15:   * The Original Code is [Open Source Virtual Machine].

• 15:   * The Original Code is [Open Source Virtual Machine].

• 114:   TOK_XMLSTAGO = 59, /* XML start tag open (<) */
• 115:   TOK_XMLETAGO = 60, /* XML end tag open (</) */
• 385:   * Return null on file-open or memory-allocation failure.

• 487:   FILE *open(const char *fname, const char *mode) {
• 488:   return mFile = fopen(fname, mode);
• 514:   fp.open("/tmp/evalcache.stats", "w");
• 553:   fp.open("/tmp/function.stats", "a");

• 1265:   JSXMLArray *inScopeNSes, JSBool isAttributeName)
• 1304:   n = inScopeNSes->length;
• 1307:   ns = XMLARRAY_MEMBER(inScopeNSes, n, JSObject);
• 1340:   n = inScopeNSes->length;
• 1343:   ns = XMLARRAY_MEMBER(inScopeNSes, n, JSObject);
• 1386:   JSXMLArray *inScopeNSes, uintN flags)
• 1416:   length = inScopeNSes->length;
• 1418:   xml = ParseNodeToXML(jsc, pn2, inScopeNSes, flags);
• 1443:   kid = ParseNodeToXML(jsc, pn2, inScopeNSes, flags);
• 1470:   XMLARRAY_TRUNCATE(cx, inScopeNSes, length);
• 1494:   kid = ParseNodeToXML(jsc, pn2, inScopeNSes, flags);
• 1513:   length = inScopeNSes->length;
• 1586:   if (!XMLARRAY_HAS_MEMBER(inScopeNSes, ns, namespace_identity)) {
• 1587:   if (!XMLARRAY_APPEND(cx, inScopeNSes, ns) ||
• 1610:   ns = XMLARRAY_MEMBER(inScopeNSes, 0, JSObject);
• 1623:   qn = ParseNodeToQName(jsc, pn2, inScopeNSes, JS_FALSE);
• 1634:   qn = ParseNodeToQName(jsc, pn2, inScopeNSes, JS_TRUE);
• 1674:   XMLARRAY_TRUNCATE(cx, inScopeNSes, length);
• 1701:   qn = ParseNodeToQName(jsc, pn, inScopeNSes, JS_FALSE);
• 1921:   * x.[[InScopeNamespaces]] >= x.[[Parent]].[[InScopeNamespaces]]
• 1923:   * must union x.[[InScopeNamespaces]] into x[0].[[InScopeNamespaces]] here
• 1929:   * default namespace thereby unioned into x[0].[[InScopeNamespaces]] must be
• 2344:  /* 13.3.5.4 [[GetNamespace]]([InScopeNamespaces]) */
• 2346:  GetNamespace(JSContext *cx, JSObject *qn, const JSXMLArray *inScopeNSes)
• 2366:   /* Look for a matching namespace in inScopeNSes, if provided. */
• 2368:   if (inScopeNSes) {
• 2369:   for (i = 0, n = inScopeNSes->length; i < n; i++) {
• 2370:   ns = XMLARRAY_MEMBER(inScopeNSes, i, JSObject);
• 2864:   /* Steps 19 through 25: handle element content, and open the end-tag. */
• 3113:  /* ECMA-357 9.1.1.13 XML [[AddInScopeNamespace]]. */
• 3115:  AddInScopeNamespace(JSContext *cx, JSXML *xml, JSObject *ns)
• 3158:   if (!AddInScopeNamespace(cx, xml, match))
• 3873:  SyncInScopeNamespaces(JSContext *cx, JSXML *xml)
• 3927:   !SyncInScopeNamespaces(cx, kid)) {
• 4564:   ok = AddInScopeNamespace(cx, xml, ns);
• 4656:   ok = AddInScopeNamespace(cx, vxml, ns);
• 5526:   if (!AddInScopeNamespace(cx, xml, ns))
• 6095:  FindInScopeNamespaces(JSContext *cx, JSXML *xml, JSXMLArray *nsarray)
• 6136:  xml_inScopeNamespaces(JSContext *cx, uintN argc, jsval *vp)
• 6144:   ok = FindInScopeNamespaces(cx, xml, &namespaces.array) &&
• 6247:   JSTempRootedNSArray inScopeNSes;
• 6267:   InitTempNSArray(cx, &inScopeNSes);
• 6269:   ok = FindInScopeNamespaces(cx, xml, &inScopeNSes.array);
• 6274:   ns = GetNamespace(cx, xml->name, &inScopeNSes.array);
• 6281:   for (i = 0, length = inScopeNSes.array.length; i < length; i++) {
• 6282:   ns = XMLARRAY_MEMBER(&inScopeNSes.array, i, JSObject);
• 6295:   FinishTempNSArray(cx, &inScopeNSes);
• 6864:   * AddInScopeNamespace(cx, nsowner, ns).
• 6904:   if (!AddInScopeNamespace(cx, nsowner, ns))
• 6952:   if (!AddInScopeNamespace(cx, nsowner, ns))
• 7122:   JS_FN("inScopeNamespaces", xml_inScopeNamespaces, 0,0),

• 5271:   fd = open("/proc/self/auxv", O_RDONLY);
• 11216:   traceVisLogFile = fopen(filename, "wb");

• 655:   cerr << "unable to open file " << args[0] << endl;

• 56:   if(keyList.Open(hkeyRoot, szKey, KEY_READ) != ERROR_SUCCESS)
• 96:   if(key.Open(HKEY_CLASSES_ROOT, _T("CLSID"), KEY_READ) != ERROR_SUCCESS)
• 97:   return PR_FALSE; // Must fail if we can't even open this!
• 105:   LONG lResult = keyCLSID.Open(key, W2CT(szCLSID), KEY_READ);
• 127:   return PR_FALSE; // Must fail if we can't open the category manager
• 221:   if(keyExplorer.Open(HKEY_LOCAL_MACHINE,
• 230:   if(keyCLSID.Open(keyExplorer, W2T(szCLSID), KEY_READ) == ERROR_SUCCESS)

• 243:   : fopen(dumpName, "w");

• 950:   LOG(("opened fastload file for reading\n"));
• 1027:   // Start our update timer. This allows us to keep the stream open
• 1274:   rv = aComponent->OpenNSPRFileDesc(PR_RDONLY, 0, &fileHandle);
• 1318:   rv = aComponent->OpenANSIFileDesc("r", &fileHandle);

• 68:  #define LOAD_ERROR_NOSTREAM "Error opening input stream (invalid filename?)"
• 295:   rv = NS_OpenURI(getter_AddRefs(instream), uri, serv,

• 449:   file = fopen(filename, "r");
• 451:   JS_ReportError(cx, "cannot open file '%s' for reading", filename);
• 604:   dumpFile = fopen(fileName, "w");
• 606:   fprintf(gErrFile, "dumpHeap: can't open %s: %s\n",
• 933:   file = fopen(filename, "r");
• 936:   JSSMSG_CANT_OPEN,
• 969:   rcfile = fopen(rcfilename, "r");

• 338:   if(NS_FAILED(aFile->OpenANSIFileDesc("w", &out)) || ! out)

• 115:   if(NS_FAILED(aFile->OpenANSIFileDesc("r", &handle)))

• 373:   if (!dumpfp) dumpfp = fopen("/tmp/jsdhash.bigdump", "w");

• 88:  #if _POSIX_C_SOURCE >= 200112L || _XOPEN_SOURCE >= 600 || MOZ_MEMORY
• 3709:   fp = fopen("/tmp/scopedepth.stats", "w");
• 3726:   lsfp = fopen("/tmp/loopstats", "w");

• 73:   fp = fopen(argv[1], "w");
• 75:   perror("fopen");

• 3945:   * scope is not yet open. Initializer evaluation uses the parent node's
• 5352:   * EmitNonLocalJumpFixup may add fixup bytecode to close open try
• 7096:   fp = fopen("/tmp/srcnotes.hist", "w");

• 4774:   fp = fopen(filename, "r");
• 4776:   JS_ReportErrorNumber(cx, js_GetErrorMessage, NULL, JSMSG_CANT_OPEN,

• 375:   file = fopen(filename, "r");
• 378:   JSSMSG_CANT_OPEN, filename, strerror(errno));
• 1827:   file = fopen(script->filename, "r");
• 1830:   JSSMSG_CANT_OPEN, script->filename,
• 1907:   file = fopen(name, "w");
• 1909:   JS_ReportError(cx, "tracing: couldn't open output file %s: %s",
• 2104:   dumpFile = fopen(fileName, "w");
• 2106:   JS_ReportError(cx, "can't open %s: %s", fileName, strerror(errno));
• 3554:   file = fopen(pathname, "rb");
• 3556:   JS_ReportError(cx, "can't open %s: %s", pathname, strerror(errno));

• 918:  OpenObject(JSContext *cx, JSONParser *jp)
• 928:  OpenArray(JSContext *cx, JSONParser *jp)
• 1127:   if (!OpenObject(cx, jp) || !PushState(cx, jp, JSON_PARSE_STATE_OBJECT_PAIR))
• 1131:   if (!OpenArray(cx, jp) || !PushState(cx, jp, JSON_PARSE_STATE_VALUE))

• 333:   logfp = fopen("/tmp/scope.log", "w");

• 1719:   logfp = fopen("/tmp/proptree.stats", "w");
• 1928:   FILE *dumpfp = fopen("/tmp/proptree.dump", "w");

• 440:   opt.output = fopen(argv[1], "w");
• 442:   perror("fopen");

• 649:   * If there's no stacked open parenthesis, throw syntax error.
• 727:   * If there's no stacked open parenthesis, throw syntax error.
• 744:   /* Process everything on the stack until the open parenthesis. */

• 647:   * gen can be open on shutdown when close hooks are ignored or when
• 651:   gen->state == JSGEN_OPEN);
• 822:   JS_ASSERT(gen->state == JSGEN_NEWBORN || gen->state == JSGEN_OPEN);
• 826:   if (gen->state == JSGEN_OPEN) {
• 877:   gen->state = JSGEN_OPEN;

• 4:  Copyright (c) 1993, 1994, 1998 The Open Group.
• 18:  OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
• 22:  Except as contained in this notice, the name of The Open Group shall not be
• 24:  in this Software without prior written authorization from The Open Group.

• 238:  #if defined(__386BSD__) || defined(__NetBSD__) || defined(__FreeBSD__) || defined(__OpenBSD__)
• 276:  #if defined(__386BSD__) || defined(__NetBSD__) || defined(__FreeBSD__) || defined(__OpenBSD__) || defined(MACH)
• 722:  #ifdef __OpenBSD__
• 723:   {"__OpenBSD__", "1"},

• 4445:   /* Skip any #n= prefix to find the opening bracket. */

• 1919:   * closures, and this can be detected via mutation. Open question:
• 6433:   * an expression in an open parenthesis, parse the tail of the comprehension
• 7416:   * that opens the end tag for the container.
• 7552:   /* Get element contents and delimiting end-tag-open sequence. */
• 7824:   * An array comprehension opens exactly one block scope, no matter

• 101:   JSGEN_OPEN, /* started by a .next() or .send(undefined) call */

• 58:  # define POPEN _popen
• 69:  # define POPEN popen
• 80:  # define POPEN popen
• 178:   if (!file->isOpen) { \
• 180:   "File %s is closed, will open it for writing, proceeding", \
• 182:   js_FileOpen(cx, obj, file, "write,append,create"); \
• 191:   if (!file->isOpen) { \
• 193:   "File %s is closed, will open it for reading, proceeding", \
• 195:   js_FileOpen(cx, obj, file, "read"); \
• 203:  #define JSFILE_CHECK_OPEN(op) \
• 204:   if (!file->isOpen) { \
• 206:   JSFILEMSG_FILE_MUST_BE_OPEN, op); \
• 211:   if (file->isOpen) { \
• 241:   JSBool isOpen;
• 242:   int32 mode; /* mode used to open the file: read, write, append, create, etc.. */
• 253:   PRFileDesc *handle; /* the handle for the file, if open. */
• 260:  static JSBool file_open(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval);
• 773:   file->isOpen = JS_FALSE;
• 785:  js_FileOpen(JSContext *cx, JSObject *obj, JSFile *file, char *mode){
• 795:   if (!file_open(cx, obj, 2, v, &rval))
• 1060:   if (file->isOpen && !(file->mode & PR_RDONLY))
• 1066:   /* Is this pipe open for reading? */
• 1077:   if (file->isOpen && !(file->mode & PR_WRONLY))
• 1083:   /* Is this pipe open for writing? */
• 1097:   if (file->isOpen
• 1098:   ? PR_GetOpenFileInfo(file->handle, &info)
• 1122:   if (file->isOpen
• 1123:   ? PR_GetOpenFileInfo(file->handle, &info)
• 1144:   if (file->isOpen
• 1145:   ? PR_GetOpenFileInfo(file->handle, &info)
• 1219:  file_open(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
• 1229:   SECURITY_CHECK(cx, NULL, "open", file);
• 1231:   /* A native file that is already open */
• 1232:   if(file->isOpen && file->isNative) {
• 1233:   JS_ReportWarning(cx, "Native file %s is already open, proceeding",
• 1239:   if (file->isOpen) {
• 1240:   JS_ReportWarning(cx, "File %s is already open, we will close it and "
• 1241:   "reopen, proceeding", file->path);
• 1248:   "trying to open it, proceeding", file->path);
• 1260:   JSFILEMSG_FIRST_ARGUMENT_OPEN_NOT_STRING_ERROR,
• 1300:   JSFILEMSG_SECOND_ARGUMENT_OPEN_NOT_STRING_ERROR,
• 1329:   * POPEN.
• 1339:   SECURITY_CHECK(cx, NULL, "pipe_open", file);
• 1344:   JSFILEMSG_OPEN_MODE_NOT_SUPPORTED_WITH_PIPES,
• 1348:   /* open(SPOOLER, "| cat -v | lpr -h 2>/dev/null") -- pipe for writing */
• 1354:   file->nativehandle = POPEN(&file->path[1], pipemode);
• 1360:   /* open(STATUS, "netstat -an 2>&1 |") */
• 1366:   file->nativehandle = POPEN(command, pipemode);
• 1376:   file->handle = PR_Open(file->path, mask, 0644);
• 1383:   /* Set the open flag and return result */
• 1385:   file->isOpen = JS_FALSE;
• 1388:   JSFILEMSG_OP_FAILED, "open", file->path);
• 1393:   file->isOpen = JS_TRUE;
• 1410:   if(!file->isOpen){
• 1411:   JS_ReportWarning(cx, "File %s is not open, can't close it, proceeding",
• 1478:   JSBool fileInitiallyOpen=JS_FALSE;
• 1484:   fileInitiallyOpen = file->isOpen;
• 1489:   /* make sure we are not reading a file open for writing */
• 1490:   if (file->isOpen && !js_canRead(cx, file)) {
• 1492:   JSFILEMSG_CANNOT_COPY_FILE_OPEN_FOR_WRITING_ERROR, file->path);
• 1498:   JSFILEMSG_OP_FAILED, "open", file->path);
• 1502:   handle = PR_Open(dest, PR_WRONLY|PR_CREATE_FILE|PR_TRUNCATE, 0644);
• 1506:   JSFILEMSG_OP_FAILED, "open", dest);
• 1538:   if(!fileInitiallyOpen){
• 1551:   if(file->isOpen && !fileInitiallyOpen){
• 1601:   JSFILE_CHECK_OPEN("flush");
• 1942:   dir = PR_OpenDir(file->path);
• 1945:   JSFILEMSG_OP_FAILED, "open", file->path);
• 2101:   if(file->isOpen && !file->isNative) {
• 2161:   int32 mode, JSBool open, JSBool randomAccess)
• 2182:   file->isOpen = open;
• 2230:   { "open", file_open, 0},
• 2260:   FILE_OPEN = -11,
• 2286:   {"isOpen", FILE_OPEN, JSPROP_ENUMERATE | JSPROP_READONLY },
• 2355:   case FILE_OPEN:
• 2356:   SECURITY_CHECK(cx, NULL, "isOpen", file);
• 2357:   *vp = BOOLEAN_TO_JSVAL(file->isOpen);
• 2361:   JSFILE_CHECK_OPEN("canAppend");
• 2367:   JSFILE_CHECK_OPEN("canReplace");
• 2373:   JSFILE_CHECK_OPEN("hasAutoFlush");
• 2378:   JSFILE_CHECK_OPEN("type");
• 2401:   JSFILE_CHECK_OPEN("mode");
• 2447:   if(((file->isOpen)?
• 2448:   PR_GetOpenFileInfo(file->handle, &info):
• 2466:   if(((file->isOpen)?
• 2467:   PR_GetOpenFileInfo(file->handle, &info):
• 2495:   if(!(dir = PR_OpenDir(file->path))){
• 2497:   JSFILEMSG_CANNOT_OPEN_DIR, file->path);
• 2521:   JSFILE_CHECK_OPEN("hasRandomAccess");
• 2527:   JSFILE_CHECK_OPEN("position");
• 2535:   if (file->isOpen && js_isFile(cx, file)) {
• 2566:   dir = PR_OpenDir(file->path);
• 2569:   JS_ReportWarning(cx, "Can't open directory %s", file->path);
• 2615:   if (file->isOpen && js_isFile(cx, file)) {

• 506:   fp = fopen("/tmp/propcache.stats", "w");
• 1462:   * Store *rval in the a scoped local root if a scope is open, else in
• 2246:   fp = fopen(name, "w");
• 2301:   fp = fopen(name, "w");
• 4648:   * Open-code JS_PROPERTY_CACHE_TEST, specializing for two
• 4848:   /* Open-coded ELEMENT_OP optimized for strings and dense arrays. */

• 663:   * correspond to indexes in the half-open range [newlen, oldlen). See

• 2700:   FILE *file = !fileName.IsEmpty() ? fopen(PromiseFlatCString(fileName).get(), "w") : stdout;

• 769:   FILE* f = fopen(filePath, "r");

• 162:  /** Device opening modes */
• 318:  /** Normal way to open a PCM device */
• 322:  int sa_stream_open(sa_stream_t *s);

• 51:   * When using an OGGZ* opened with the OGGZ_AUTO flag set, Oggz will
• 86:   * \param oggz An OGGZ handle previously opened for reading
• 126:   * \param oggz An OGGZ handle previously opened for reading
• 150:   * \param oggz An OGGZ handle previously opened for reading
• 168:   * \param oggz An OGGZ handle previously opened for reading

• 50:   * \note Opening a file with oggz_open() or oggz_open_stdio() is equivalent
• 127:   * open for reading.
• 150:   * open for writing.
• 222:   * open for writing.

• 63:   * - A simple, callback based open/read/close or open/write/close
• 90:   * liboggz is provided under the following BSD-style open source license:
• 324:   * - Any attempt to call oggz_new(), oggz_open() or oggz_open_stdio()
• 334:   * - Any attempt to call oggz_new(), oggz_open() or oggz_open_stdio()
• 391:   * - oggz_open() - Open a full pathname
• 392:   * - oggz_open_stdio() - Use an already opened FILE *
• 421:   * When an OGGZ handle is instantiated by oggz_open() or oggz_open_stdio(),
• 438:   * An opaque handle to an Ogg file. This is returned by oggz_open() or
• 452:   * Open an Ogg file, creating an OGGZ handle for it
• 453:   * \param filename The file to open
• 458:  OGGZ * oggz_open (const char * filename, int flags);
• 462:   * \param file An open FILE handle
• 467:  OGGZ * oggz_open_stdio (FILE * file, int flags);
• 483:   * For an OGGZ opened for reading, an OggzReadPacket or OggzReadPage callback
• 485:   * For an OGGZ opened for writing, either an OggzHungry callback should have
• 488:   * \param oggz An OGGZ handle previously opened for either reading or writing
• 504:   * \param oggz An OGGZ handle previously opened for either reading or writing

• 59:   * You need to open the file with the OGGZ_AUTO flag set:
• 470:   * \param oggz An OGGZ handle previously opened for reading
• 483:   * \param oggz An OGGZ handle previously opened for reading

• 129:   * \param oggz An OGGZ handle previously opened for writing
• 148:   * \param oggz An OGGZ handle previously opened for writing
• 193:   * \param oggz An OGGZ handle previously opened for writing
• 213:   * \param oggz An OGGZ handle previously opened for writing
• 231:   * \param oggz An OGGZ handle previously opened for writing

• 135:  /* Some systems need _XOPEN_SOURCE for timezone */
• 136:  /* #undef _XOPEN_SOURCE */

• 41:   * Flags to oggz_new(), oggz_open(), and oggz_openfd().
• 59:   * metrics appropriately. Opening a file for reading with

• 69:   * @param filename The file to open

• 71:  oggplay_open_with_reader(OggPlayReader *reader);

• 89:   * libfishsound is provided under the following BSD-style open source license:

• 862:   rv = localFile->OpenNSPRFileDesc(PR_RDONLY, 0444, &fd);
• 1212:   nsresult rv = localFile->OpenNSPRFileDesc(PR_WRONLY | PR_CREATE_FILE | PR_TRUNCATE, 0664, &fd);

• 529:   // Leave it to Microsoft to open an existing file with a function
• 535:   OPEN_EXISTING,
• 737:   mDir = PR_OpenDir(inDirectory);

• 59:   void open(in nsIFile regFile);
• 60:   void openWellKnownRegistry(in nsWellKnownRegistry regid);
• 63:   boolean isOpen();

• 438:   rv = OpenStreamForWriting();
• 495:  NS_IMETHODIMP nsFileSpecImpl::OpenStreamForReading()
• 504:  NS_IMETHODIMP nsFileSpecImpl::OpenStreamForWriting()
• 513:  NS_IMETHODIMP nsFileSpecImpl::OpenStreamForReadingAndWriting()
• 534:  NS_IMETHODIMP nsFileSpecImpl::IsStreamOpen(PRBool *_retval)
• 548:   nsresult rv = OpenStreamForReading();
• 562:   nsresult rv = OpenStreamForWriting();
• 574:   nsresult rv = OpenStreamForWriting();
• 588:   nsresult rv = OpenStreamForReading();
• 659:   nsresult rv = OpenStreamForReading();
• 678:   nsresult rv = OpenStreamForReading();
• 698:   nsresult rv = OpenStreamForWriting();

• 580:   rc = DosOpen(mPath,
• 585:   OPEN_ACTION_FAIL_IF_NEW | OPEN_ACTION_OPEN_IF_EXISTS,
• 586:   OPEN_SHARE_DENYREADWRITE | OPEN_ACCESS_READWRITE,
• 602:   // Leave it to Microsoft to open an existing file with a function
• 608:   OPEN_EXISTING,
• 784:   mDir = PR_OpenDir(inDirectory);

• 347:   // if you really must pass a string to PR_OpenFile().

• 305:   nsErrorProne() // for delayed opening
• 332:   nsFileClient(const nsCOMPtr<nsIOpenFile>& inFile)
• 338:   void open(
• 344:   mResult = mFile->Open(inFile, nsprMode, accessMode);
• 346:   PRBool is_open() const
• 350:   mFile->GetIsOpen(&result);
• 360:   nsFileClient() // for delayed opening
• 365:   nsCOMPtr<nsIOpenFile> mFile;
• 377:   nsRandomAccessStoreClient() // for delayed opening
• 504:   void Open(
• 510:   mFile->Open(inFile, nsprMode, accessMode);

• 39:  // Since nsFileStream.h is entirely templates, common code (such as open())
• 287:  // if (is_open())
• 322:  // if (is_open())

• 113:   char *mCurRegFile; // these are to prevent open from opening the registry again
• 386:  | The dtor closes the registry file(if open). |
• 401:  /*----------------------------- nsRegistry::Open -------------------------------
• 402:  | If the argument is null, delegate to OpenDefault, else open the registry |
• 403:  | file. We first check to see if a registry file is already open and close |
• 406:  NS_IMETHODIMP nsRegistry::Open( nsIFile *regFile ) {
• 411:   return OpenWellKnownRegistry(nsIRegistry::ApplicationRegistry);
• 419:   printf("nsRegistry: Opening registry %s\n", regPath.get());
• 424:   // Can't open another registry without closing explictly.
• 428:   // Do we have an open registry ?
• 434:   // The right one is already open
• 439:   // Opening a new registry without closing an already open one.
• 445:   // Open specified registry.
• 447:   err = NR_RegOpen(const_cast<char*>(regPath.get()), &mReg);
• 512:  /*----------------------------- nsRegistry::OpenWellKnownRegistry --------------
• 513:  | Takes a registry id and maps that to a file name for opening. We first check |
• 514:  | to see if a registry file is already open and close it if so. |
• 516:  NS_IMETHODIMP nsRegistry::OpenWellKnownRegistry( nsWellKnownRegistry regid )
• 522:   // Can't open another registry without closing explictly.
• 528:   // Already opened.
• 571:   printf("nsRegistry: Opening std registry %s\n", regFile.get());
• 575:   err = NR_RegOpen(const_cast<char*>(regFile.get()), &mReg );
• 578:   // Store the registry that was opened for optimizing future opens.
• 586:  /*-------------------------- nsRegistry::OpenDefault ---------------------------
• 587:  | Open the "default" registry; in the case of this libreg-based implementation |
• 588:  | that is done by passing a null file name pointer to NR_RegOpen. |
• 590:  NS_IMETHODIMP nsRegistry::OpenDefault() {
• 591:   return OpenWellKnownRegistry(nsIRegistry::ApplicationRegistry);
• 624:  /*----------------------------- nsRegistry::IsOpen -----------------------------
• 625:  | Tests the mReg handle and returns whether the registry is open or not. |
• 627:  NS_IMETHODIMP nsRegistry::IsOpen( PRBool *result ) {

• 71:   nsCOMPtr<nsIFile> mCurRegFile; // these are to prevent open from opening the registry again

• 64:   , public nsIOpenFile
• 74:   // nsIOpenFile interface
• 75:   NS_IMETHOD Open(const nsFileSpec& inFile, int nsprMode, PRIntn accessMode);
• 77:   NS_IMETHOD GetIsOpen(PRBool* outOpen);
• 127:   NS_IMPL_QUERY_BODY(nsIOpenFile)
• 164:   nsresult rv = Open(inFile, nsprMode, accessMode); // this sets nsprMode
• 171:   printf("Opening file %s failed\n", fileName);
• 191:  NS_IMETHODIMP FileImpl::Open(
• 225:   // Use the file spec to open the file, because one path can be common to
• 276:   err = FSpOpenDF(&spec, perm, &refnum);
• 289:   // Another bug in NSPR: Mac PR_Open assumes a unix style path, but Win PR_Open assumes
• 291:   if ((mFileDesc = PR_Open((const char*)nsFileSpec(inFile), nsprMode, accessMode)) == 0)
• 297:  } // FileImpl::Open
• 314:  NS_IMETHODIMP FileImpl::GetIsOpen(PRBool* outOpen)
• 317:   *outOpen = (mFileDesc != nsnull && !mFailed);
• 718:   PRBool isOpened = PR_FALSE;
• 719:   stream->GetIsOpen(&isOpened);
• 720:   if (!isOpened)

• 49:  #define NS_IOPENFILE_IID \
• 54:  class nsIOpenFile
• 55:  // Represents a file, and supports Open.
• 60:   NS_DECLARE_STATIC_IID_ACCESSOR(NS_IOPENFILE_IID)
• 62:   NS_IMETHOD Open(
• 66:   // Note: Open() is only needed after
• 68:   // are automatically opened on construction.
• 69:   NS_IMETHOD GetIsOpen(PRBool* outOpen) = 0;
• 71:  }; // class nsIOpenFile
• 73:  NS_DEFINE_STATIC_IID_ACCESSOR(nsIOpenFile, NS_IOPENFILE_IID)

• 140:   void openStreamForReading();
• 141:   void openStreamForWriting();
• 142:   void openStreamForReadingAndWriting();
• 144:   boolean isStreamOpen();

• 487:   // Open the input file for binary read
• 488:   pFileDescIn = PR_Open(in, PR_RDONLY, 0444);
• 491:   return -1; // Open failed, return an error
• 494:   // Open the output file for binary write
• 495:   pFileDescOut = PR_Open(out, PR_WRONLY | PR_CREATE_FILE, 0600);
• 498:   // Open failed, need to close input file, then return an error
• 500:   return -1; // Open failed, return an error
• 670:   mDir = opendir((const char*)nsFilePath(inDirectory));

• 360:   ifp = fopen (in, "r");
• 366:   ofp = fopen (out, "w");
• 502:   mDir = opendir((const char*)nsFilePath(inDirectory));

• 120:   RegOpenKeyExW(HKEY_CURRENT_USER, L"Software\\mozilla.org\\windbgdlg", 0, KEY_READ, &hkeyCU);
• 121:   RegOpenKeyExW(HKEY_LOCAL_MACHINE, L"Software\\mozilla.org\\windbgdlg", 0, KEY_READ, &hkeyLM);

• 83:   tfp = fopen(tfn, "w");
• 938:  nsFastLoadFileReader::Open()
• 1225:   nsresult rv = reader->Open();
• 1475:   // If there is a muxed document segment open, close it now by setting its
• 1916:  nsFastLoadFileWriter::Open()
• 1944:   // If there is a muxed document segment open, close it now by setting its
• 2309:   nsresult rv = writer->Open();
• 2372:  nsFastLoadFileUpdater::Open(nsFastLoadFileReader* aReader)
• 2445:   // same FastLoad episode in this session* race to open a navigator
• 2451:   // messenger.xul being opened here has already read it.
• 2571:   nsresult rv = updater->Open(static_cast<nsFastLoadFileReader*>

• 169:   mDir = opendir(dirPath.get());
• 396:  nsLocalFile::OpenNSPRFileDesc(PRInt32 flags, PRInt32 mode, PRFileDesc **_retval)
• 398:   *_retval = PR_Open(mPath.get(), flags, mode);
• 410:  nsLocalFile::OpenANSIFileDesc(const char *mode, FILE **_retval)
• 412:   *_retval = fopen(mPath.get(), mode);
• 422:   *_retval = PR_Open(path, flags, mode);
• 434:  nsLocalFile::CreateAndKeepOpen(PRUint32 type, PRIntn flags,
• 483:   nsresult rv = CreateAndKeepOpen(type,
• 807:   // open it successfully for writing.
• 810:   rv = newFile->CreateAndKeepOpen(NORMAL_FILE_TYPE,
• 817:   // open the old file, too
• 833:   rv = OpenNSPRFileDesc(PR_RDONLY, myPerms, &oldFD);

• 1084:   // input stream may remain open

• 107:   * Return the result of PR_Open on the file. The caller is
• 110:   * @param flags the PR_Open flags from prio.h, plus optionally
• 112:   * the file (by path name) immediately after opening it, so beware
• 116:   [noscript] PRFileDescStar openNSPRFileDesc(in long flags, in long mode);
• 119:   * Return the result of fopen on the file. The caller is
• 122:   [noscript] FILE openANSIFileDesc(in string mode);
• 159:   * Ask the operating system to open the folder which contains
• 161:   * support the ability to open a folder...
• 168:   * Ask the operating system to attempt to open the file.

• 388:   nsresult Open();
• 480:   nsresult Open();
• 560:   nsresult Open(nsFastLoadFileReader* aReader);

• 295:   mDir = PR_OpenDir(filepath.get());
• 724:  nsLocalFile::OpenNSPRFileDesc(PRInt32 flags, PRInt32 mode, PRFileDesc **_retval)
• 730:   *_retval = PR_Open(mWorkingPath.get(), flags, mode);
• 743:  nsLocalFile::OpenANSIFileDesc(const char *mode, FILE * *_retval)
• 749:   *_retval = fopen(mWorkingPath.get(), mode);
• 817:   PRFileDesc* file = PR_Open(mWorkingPath.get(), PR_RDONLY | PR_CREATE_FILE | PR_APPEND | PR_EXCL, attributes);
• 1405:   if (rc == ERROR_TOO_MANY_OPEN_FILES) {
• 1413:   } while (rc == ERROR_TOO_MANY_OPEN_FILES);
• 1940:   rc = DosOpen(mWorkingPath.get(),
• 1945:   OPEN_ACTION_FAIL_IF_NEW | OPEN_ACTION_OPEN_IF_EXISTS,
• 1946:   OPEN_SHARE_DENYREADWRITE | OPEN_ACCESS_READWRITE,
• 2365:  #ifndef OPEN_DEFAULT
• 2366:  #define OPEN_DEFAULT 0
• 2367:  #define OPEN_CONTENTS 1
• 2391:   WinOpenObject(hobject, OPEN_DEFAULT, TRUE);
• 2403:   WinOpenObject(hobject, OPEN_DEFAULT, TRUE);

• 179:   * openDocWithApp
• 181:   * Open the document that this file points to with the given application.
• 183:   * @param aAppToOpenWith The application with which to open the document.
• 189:   void openDocWithApp(in nsILocalFile aAppToOpenWith, in boolean aLaunchInBackground);

• 310:   file = fopen (config_file, "r");

• 146:   nsresult CreateAndKeepOpen(PRUint32 type, PRIntn flags,

• 135:  #include <iconv.h> // iconv_open, iconv, iconv_close
• 194:  xp_iconv_open(const char **to_list, const char **from_list)
• 207:   res = iconv_open(*to_name, *from_name);
• 351:   gNativeToUnicode = xp_iconv_open(UTF_16_NAMES, native_charset_list);
• 352:   gUnicodeToNative = xp_iconv_open(native_charset_list, UTF_16_NAMES);
• 356:   gNativeToUTF8 = xp_iconv_open(UTF_8_NAMES, native_charset_list);
• 357:   gUTF8ToUnicode = xp_iconv_open(UTF_16_NAMES, UTF_8_NAMES);
• 362:   gUnicodeToUTF8 = xp_iconv_open(UTF_8_NAMES, UTF_16_NAMES);
• 363:   gUTF8ToNative = xp_iconv_open(native_charset_list, UTF_8_NAMES);

• 334:  // We need the following three definitions to make |OpenFile| convert a file
• 369:  // Six static methods defined below (OpenFile, FileTimeToPRTime, GetFileInfo,
• 370:  // OpenDir, CloseDir, ReadDir) should go away once the corresponding
• 377:  // PR_Open and _PR_MD_OPEN
• 379:  OpenFile(const nsAFlatString &name, PRIntn osflags, PRIntn mode,
• 400:   flags = OPEN_ALWAYS;
• 405:   flags = OPEN_EXISTING;
• 424:   // add it manually. (see |PR_Open| in nsprpub/pr/src/io/prfile.c)
• 498:  OpenDir(const nsAFlatString &name, nsDir * *dir)
• 633:   nsresult rv = OpenDir(filepath, &mDir);
• 945:  nsLocalFile::OpenNSPRFileDesc(PRInt32 flags, PRInt32 mode, PRFileDesc **_retval)
• 951:   return OpenFile(mResolvedPath, flags, mode, _retval);
• 956:  nsLocalFile::OpenANSIFileDesc(const char *mode, FILE * *_retval)
• 962:   *_retval = _wfopen(mResolvedPath.get(), NS_ConvertASCIItoUTF16(mode).get());
• 1040:   rv = OpenFile(mResolvedPath,
• 1962:   OPEN_EXISTING, // how to create
• 2163:   OPEN_EXISTING, // how to create
• 2754:   // Always open a new window for files because Win2K doesn't appear to select
• 2755:   // the file if a window showing that folder was already open. If the resolved
• 2756:   // path is a directory then instead of opening the parent and selecting it,
• 2757:   // we open the directory itself.
• 2765:   if (::ShellExecuteW(NULL, L"open", explorerPath.get(), explorerParams.get(),
• 2807:   shellArg.Assign(NS_LITERAL_STRING("shell32.dll,OpenAs_RunDLL ") + path);

• 273:   FILE *fp = _fdopen(_dup(2), "a");

• 1:  /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2; c-file-offsets: ((substatement-open . 0)) -*- */

• 67:   * the class does not hold a file handle open. An instance must only be
• 75:   * the class does not hold a file handle open. An instance must only

• 48:   (defined(OPENBSD) || defined(NETBSD)) && !defined(__ELF__)
• 79:   void *libHandle = dlopen(aDependentLib, RTLD_GLOBAL | RTLD_LAZY);
• 99:   sXULLibHandle = dlopen(xpcomDir, RTLD_GLOBAL | RTLD_LAZY);
• 109:   libHandle = dlopen(xpcomFile, RTLD_GLOBAL | RTLD_LAZY);

• 94:  inline FILE *TS_tfopen (const char *path, const wchar_t *mode)
• 98:   return _wfopen(wPath, mode);
• 101:  inline FILE *TS_tfopen (const char *path, const char *mode)
• 103:   return fopen(path, mode);
• 114:   FILE *flist = TS_tfopen(buffer, READ_TEXTMODE);

• 45:   * 07/02/2001 09:17p 509,104 clangref.pdf from openwatcom's site

• 446:   if (::RegOpenKeyExW(HKEY_CURRENT_USER, GRE_WIN_REG_LOC, 0,
• 458:   if (::RegOpenKeyExW(HKEY_LOCAL_MACHINE, GRE_WIN_REG_LOC, 0,
• 564:   DIR *dir = opendir(buffer);
• 604:   // Open the directory provided and try to read any files in that
• 607:   DIR *dir = opendir(dirname);
• 776:   if (::RegOpenKeyExW(aRegKey, name, 0, KEY_QUERY_VALUE, &subKey) !=

• 61:  inline FILE *TS_tfopen (const char *path, const wchar_t *mode)
• 65:   return _wfopen(wPath, mode);
• 68:  inline FILE *TS_tfopen (const char *path, const char *mode)
• 70:   return fopen(path, mode);
• 93:   /* open the file. Don't use OpenANSIFileDesc, because you mustn't
• 104:   fd = _wfopen(path.get(), READ_BINARYMODE);
• 109:   fd = fopen(path.get(), READ_BINARYMODE);
• 121:   /* open the file */
• 122:   AutoFILE fd = TS_tfopen(aPath, READ_BINARYMODE);

• 1:  /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2; c-file-offsets: ((substatement-open . 0)) -*- */

• 285:   * instead of referencing "stderr" directly, use fdopen.

• 565:   * existing data to open up the specified section.

• 216:  #error "Unsupported compiler. Use g++ >= 2.8 for OpenBSD/arm."

• 109:  #elif defined(__OpenBSD__)
• 113:  /* OpenBSD introduces GCC 2.95.x in late May 1999 */
• 115:  #if OpenBSD <= 199905

• 54:  hConHandle = _open_osfhandle(lStdHandle, _O_TEXT);
• 56:  fp = _fdopen( hConHandle, "w" );
• 66:  hConHandle = _open_osfhandle(lStdHandle, _O_TEXT);
• 68:  fp = _fdopen( hConHandle, "r" );
• 78:  hConHandle = _open_osfhandle(lStdHandle, _O_TEXT);
• 80:  fp = _fdopen( hConHandle, "w" );

• 92:   // This sets what will be returned by GetOpenLogFile().
• 128:   mOpenLogFile(nsnull),
• 411:   if(NS_FAILED(aFile->OpenNSPRFileDesc(PR_RDONLY, 0444, &fd)) || !fd)
• 1626:   PRFileDesc* fd = gInterfaceInfoManager->GetOpenLogFile();
• 1646:   PRFileDesc* fd = mgr->GetOpenLogFile();
• 1673:   // This sets what will be returned by GetOpenLogFile().
• 1676:   PRFileDesc* fd = GetOpenLogFile();
• 1895:   // This sets what will be returned by GetOpenLogFile().

• 838:  // We use this is as a fancy way to open a logfile to be used within the scope
• 879:   PRFileDesc* GetOpenLogFile() {return mOpenLogFile;}
• 880:   PRFileDesc* SetOpenLogFile(PRFileDesc* fd)
• 881:   {PRFileDesc* temp = mOpenLogFile; mOpenLogFile = fd; return temp;}
• 965:   PRFileDesc* mOpenLogFile;

• 84:   OpenNSPRFileDesc(PR_WRONLY | PR_CREATE_FILE | PR_APPEND |
• 92:   mOldFileDesc = mMgr->SetOpenLogFile(fd);
• 101:   printf("xpti failed to open log file for writing\n");
• 113:   PRFileDesc* fd = mMgr->SetOpenLogFile(mOldFileDesc);

• 143:   OpenNSPRFileDesc(PR_WRONLY | PR_CREATE_FILE | PR_TRUNCATE,
• 307:   if(NS_FAILED(aFile->OpenNSPRFileDesc(PR_RDONLY, 0444, &fd)) || !fd)

• 102:   * nsAutoRef<nsRawFD> fd(open(filename, O_RDONLY));
• 129:   * fd1.own(open("/proc/1/maps");

• 75:   GC_stderr = fopen(reportName, "w");
• 80:  static FILE* openTraceFile()
• 90:   return fopen(reportName, "w");
• 117:   FILE* trace = openTraceFile();
• 143:   FILE* trace = openTraceFile();
• 181:   // open the first leak file.

• 214:   int fd = open (kHighMark, O_RDONLY);

• 637:   FILE *stream = ::fopen(value, "w");

• 1087:   stream = fopen(fname, "w+");
• 2083:   // We can't just use _popen here because graphviz-for-windows
• 2087:   stream = fopen("c:\\cycle-graph.dot", "w+");
• 2089:   stream = popen("dotty -", "w");
• 2216:   mPtrLog = fopen("pointer_log", "w");
• 2250:   mPtrLog = fopen("pointer_log", "w");
• 2289:   mPtrLog = fopen("pointer_log", "w");
• 2321:   mPtrLog = fopen("pointer_log", "w");
• 2353:   mPtrLog = fopen("pointer_log", "w");
• 2488:   mPtrLog = fopen("pointer_log", "w");

• 1237:   if ((handle = dlopen(libdem, RTLD_LAZY)) != NULL) {

• 79:   if ((fd = open(executablePath, O_RDONLY)) == -1)

• 65:   * Values for the mode parameter passed to the open and create methods.
• 126:   * This method opens an existing key. This method fails if the key
• 131:   * Windows, that usage should probably be avoided in favor of openChild.
• 141:   void open(in unsigned long rootKey, in AString relPath, in unsigned long mode);
• 144:   * This method opens an existing key or creates a new key.
• 161:   * This method opens a subkey relative to this key. This method fails if the
• 164:   * @return nsIWindowsRegKey for the newly opened subkey.
• 166:   nsIWindowsRegKey openChild(in AString relPath, in unsigned long mode);
• 169:   * This method opens or creates a subkey relative to this key.
• 171:   * @return nsIWindowsRegKey for the newly opened or created subkey.
• 335:   * changed. The key must have been opened with mode including ACCESS_NOTIFY.

• 251:   && (fd = PR_Open(fileName, PR_WRONLY | PR_CREATE_FILE | PR_TRUNCATE,

• 115:  nsWindowsRegKey::Open(PRUint32 rootKey, const nsAString &path, PRUint32 mode)
• 119:   LONG rv = RegOpenKeyExW((HKEY) rootKey, PromiseFlatString(path).get(), 0,
• 139:  nsWindowsRegKey::OpenChild(const nsAString &path, PRUint32 mode,
• 148:   nsresult rv = child->Open((PRUint32) mKey, path, mode);
• 213:   // Check for the existance of a child key by opening the key with minimal
• 217:   LONG rv = RegOpenKeyExW(mKey, PromiseFlatString(name).get(), 0,

• 48:   FILE* fp = fopen("words.txt", "r");
• 50:   printf("can't open words.txt\n");

• 157:   PRBool stdoutOpen = PR_TRUE, stderrOpen = PR_TRUE;
• 164:   while ((stdoutOpen || stderrOpen) && now < deadline) {
• 166:   if (stdoutOpen) {
• 172:   if (stderrOpen) {
• 213:   stdoutOpen = PR_FALSE;
• 217:   stderrOpen = PR_FALSE;
• 226:   Finish(!stdoutOpen && !stderrOpen && now <= deadline);

• 156:   // Create and open first temporary directory
• 170:   fail("NTFS Permissions: Opening Temporary Directory 1");
• 175:   // Create and open temporary file
• 199:   fail("NTFS Permissions: Opening Temporary File");
• 221:   // Create and open second temporary directory
• 235:   fail("NTFS Permissions: Opening Temporary Directory 2");

• 77:   // Create and open temporary file
• 104:   fail("Test Win Attribs: Opening Test File");

• 192:  // Test nsILocalFile::OpenNSPRFileDesc with DELETE_ON_CLOSE, verifying that the file exists
• 216:   rv = file->OpenNSPRFileDesc(aFlags | nsILocalFile::DELETE_ON_CLOSE, aPerm, &fileDesc);
• 217:   if (!VerifyResult(rv, "OpenNSPRFileDesc"))
• 551:   passed("OpenNSPRFileDesc DELETE_ON_CLOSE");

• 79:   ec = NS_OpenURI(&in, url);
• 81:   printf("open of url('%s') failed: error=%x\n", urlName, ec);

• 57:   readonly attribute boolean canOpenMultipleFiles;
• 95:   const long APP_KEY_CAN_OPEN_MULTIPLE = 4;
• 120:   /* Obtain the preferred application for opening a given MIME type */
• 123:   /* Set the preferred application for opening a given MIME type */
• 146:   /* Open the given URI in the default application */

• 112:   rv = wwatcher->OpenWindow(parent, "chrome://cookie/content/cookieAcceptDialog.xul", "_blank",

• 50:  static const char kPopupDisablePref[] = "dom.disable_open_during_load";

• 40:   * An interface to open a dialog to ask to permission to accept the cookie.
• 53:   /* Open a dialog that asks for permission to accept a cookie

• 165:   rv = storage->OpenDatabase(permissionsFile, getter_AddRefs(mDBConn));
• 175:   rv = storage->OpenDatabase(permissionsFile, getter_AddRefs(mDBConn));

• 168:   /* *sob* - seems necessary to open the .so as RTLD_GLOBAL. Without
• 181:   dlopen(PYTHON_SO,RTLD_NOW | RTLD_GLOBAL);

• 784:   channel->Open(getter_AddRefs(instream));
• 786:   NS_ERROR("could not open stream");

• 103:   aTransport->OpenInputStream(nsITransport::OPEN_BLOCKING, 0, 0, getter_AddRefs(input));
• 104:   aTransport->OpenOutputStream(nsITransport::OPEN_BLOCKING, 0, 0, getter_AddRefs(output));

• 123:   case GNOME_VFS_ERROR_NOT_OPEN:
• 124:   case GNOME_VFS_ERROR_INVALID_OPEN_MODE:
• 125:   case GNOME_VFS_ERROR_TOO_MANY_OPEN_FILES:
• 358:   , mDirOpen(PR_FALSE) {}
• 381:   GnomeVFSResult DoOpen();
• 395:   PRPackedBool mDirOpen;
• 399:  nsGnomeVFSInputStream::DoOpen()
• 403:   NS_ASSERTION(mHandle == nsnull, "already open");
• 414:   // XXX We need to do this up-front in order to determine how to open the URI.
• 416:   // always returned by gnome_vfs_open when we pass it a URI to a directory!
• 417:   // Otherwise, we could have used that as a way to failover to opening the
• 422:   // the case where gnome_vfs_open would have been used. (Oh well! /me
• 441:   rv = gnome_vfs_open(&mHandle, mSpec.get(), GNOME_VFS_OPEN_READ);
• 443:   LOG(("gnomevfs: gnome_vfs_open returned %d (%s) [spec=\"%s\"]\n",
• 473:   mDirOpen = PR_TRUE;
• 516:   else if (mDirOpen)
• 694:   // Prevent future reads from re-opening the handle.
• 725:   // If this is our first-time through here, then open the URI.
• 726:   if (!mHandle && !mDirOpen)
• 727:   rv = DoOpen();
• 946:   // to something better once we open the URI.

• 778:   // TheOpenOffice.org -> The OpenOffice.org

• 21:   * Caolan McNamara (cmc@openoffice.org)

• 21:   * Caolan McNamara (cmc@openoffice.org)

• 77:   fin = fopen(filename, "rb");

• 73:  #ifdef OPENOFFICEORG
• 5362:  #ifndef OPENOFFICEORG
• 5410:  #ifdef OPENOFFICEORG
• 5430:  #ifdef OPENOFFICEORG
• 5445:  #ifdef OPENOFFICEORG

• 152:  #ifndef OPENOFFICEORG
• 282:   // Mixed caps: OpenOffice.org -> OPENOFFICE.ORG
• 427:   // open dictionary file
• 666:   // open the affix file
• 669:   HUNSPELL_WARNING(stderr, "Error - could not open affix description file %s\n",affpath);
• 713:  #ifndef OPENOFFICEORG

• 121:   langnum = 0; // language code (see http://l10n.openoffice.org/languages.html)
• 320:   // open the affix file
• 323:   HUNSPELL_WARNING(stderr, "error: could not open affix description file %s\n",affpath);
• 368:  #ifndef OPENOFFICEORG

• 106:   // open the dictionary list file
• 108:   dictlst = fopen(dictpath,"r");

• 54:   fin = fopen(file, "r");
• 64:   if (!fin && !hin) fail(MSG_OPEN, file);

• 161:   rv = obsSvc->AddObserver(this, "domwindowopened", PR_FALSE);
• 538:   if (!strcmp(aTopic,"domwindowopened"))

• 101:   PRFileDesc *fd = PR_Open(nativePath.get(), PR_RDONLY, 0);

• 116:   PRBool open;
• 117:   nsresult rv = popup->GetPopupOpen(&open);
• 119:   if (!open) {

• 789:   root->SetContainerOpen(PR_TRUE);
• 831:   root->SetContainerOpen(PR_FALSE);

• 51:  // creation, opening, closing, and destruction, and records the events into
• 67:  // <window action="open"/>: logged when window.open() is called.
• 69:  // window is opened. It will never be logged for subframe windows.
• 71:  // windowid: The id of the opened window (uint16)
• 72:  // opener: The id of the window's opener (uint16)
• 93:   void LogWindowOpen(nsITimer *timer, nsISupports *subject);
• 99:   static void WindowOpenCallback(nsITimer *timer, void *closure);
• 101:   // timers that we're using for deferred window open events
• 102:   nsTArray< nsCOMPtr<nsITimer> > mWindowOpenTimers;

• 290:   rv = file->OpenNSPRFileDesc(

• 74:   rv = obsSvc->AddObserver(this, "domwindowopened", PR_FALSE);
• 98:   rv = obsSvc->RemoveObserver(this, "domwindowopened");
• 116:  struct WindowOpenClosure
• 118:   WindowOpenClosure(nsISupports *subj, nsWindowCollector *coll)
• 126:  nsWindowCollector::WindowOpenCallback(nsITimer *timer, void *closure)
• 128:   WindowOpenClosure *wc = static_cast<WindowOpenClosure *>(closure);
• 129:   wc->collector->LogWindowOpen(timer, wc->subject);
• 135:  nsWindowCollector::LogWindowOpen(nsITimer *timer, nsISupports *subject)
• 137:   mWindowOpenTimers.RemoveElement(timer);
• 144:   nsCOMPtr<nsIDOMWindowInternal> opener;
• 145:   window->GetOpener(getter_AddRefs(opener));
• 153:   if (opener) {
• 154:   properties->SetPropertyAsUint32(NS_LITERAL_STRING("opener"),
• 155:   nsMetricsService::GetWindowID(opener));
• 162:   NS_LITERAL_CSTRING("open"));
• 213:   } else if (strcmp(topic, "domwindowopened") == 0) {
• 214:   // We'd like to log a window open event now, but the window opener
• 215:   // has not yet been set when we receive the domwindowopened notification.
• 220:   WindowOpenClosure *wc = new WindowOpenClosure(subject, this);
• 223:   rv = timer->InitWithFuncCallback(nsWindowCollector::WindowOpenCallback,
• 227:   mWindowOpenTimers.AppendElement(timer);

• 407:   rv = OpenDataFile(PR_WRONLY | PR_APPEND | PR_CREATE_FILE, &fd);
• 529:   OpenCompleteXMLStream(dataFile, getter_AddRefs(stream));
• 1169:  nsMetricsService::OpenDataFile(PRUint32 flags, PRFileDesc **fd)
• 1175:   return dataFile->OpenNSPRFileDesc(flags, 0600, fd);
• 1250:   rv = channel->AsyncOpen(this, nsnull);
• 1264:   rv = OpenCompleteXMLStream(input, getter_AddRefs(src));
• 1283:   rv = ltemp->OpenNSPRFileDesc(PR_WRONLY | PR_TRUNCATE | PR_CREATE_FILE, 0600,
• 1317:  nsMetricsService::OpenCompleteXMLStream(nsILocalFile *dataFile,

• 135:   sProcFP = fopen(buf, "rb");
• 159:   sProcess = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ,

• 165:   nsresult OpenDataFile(PRUint32 flags, PRFileDesc **result);
• 170:   nsresult OpenCompleteXMLStream(nsILocalFile *dataFile,

• 113:   // Listen for newly opened windows, so that we can attach a command event
• 115:   rv = obsSvc->AddObserver(this, "domwindowopened", PR_FALSE);
• 136:   // Remove our observer for open windows
• 137:   rv = obsSvc->RemoveObserver(this, "domwindowopened");
• 165:   if (strcmp(topic, "domwindowopened") == 0) {

• 104:   nsCOMPtr<nsIDOMWindow> opened;
• 105:   wwatch->OpenWindow(nsnull, "chrome://layoutdebug/content/",
• 107:   getter_AddRefs(opened));

• 69:   * @param aBaseFile the baseline file, opened with read permissions
• 70:   * @param aVerFile file containing the results to verify, opened with read permissions

• 120:   rv = aDestFile->OpenANSIFileDesc("w", &fp);
• 153:   rv = aBaseFile->OpenANSIFileDesc("r", &baseFile);
• 157:   rv = aVerFile->OpenANSIFileDesc("r", &verFile);

• 244:   nsCOMPtr<nsIDOMWindowInternal> opener;
• 246:   windowInternal->GetOpener(getter_AddRefs(opener));
• 247:   if (eventTarget && opener) {

• 63:   nsresult openAndEvaluateJSFile(const char *aFileName, PRInt32 obscureValue,

• 192:   // Open and evaluate function calls to set/lock/unlock prefs
• 193:   rv = openAndEvaluateJSFile("prefcalls.js", 0, PR_FALSE, PR_FALSE);
• 198:   rv = openAndEvaluateJSFile("platform.js", 0, PR_FALSE, PR_FALSE);
• 219:   rv = openAndEvaluateJSFile(lockFileName.get(), obscureValue, PR_TRUE, PR_TRUE);
• 270:  nsresult nsReadConfig::openAndEvaluateJSFile(const char *aFileName, PRInt32 obscureValue,

• 336:   // open a channel for the url
• 342:   rv = channel->AsyncOpen(this, nsnull);
• 356:   // Getting the current thread. If we start an AsyncOpen, the thread
• 440:   Open the file and read the content.
• 453:   NS_WARNING("Couldn't open failover.jsc, going back to default prefs");

• 3:   * Copyright 1993 by OpenVision Technologies, Inc.
• 9:   * supporting documentation, and that the name of OpenVision not be used
• 11:   * without specific, written prior permission. OpenVision makes no
• 15:   * OPENVISION DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
• 17:   * EVENT SHALL OPENVISION BE LIABLE FOR ANY SPECIAL, INDIRECT OR
• 143:   * We can't use X/Open definitions, so roll our own.
• 665:   int * /* open */

• 291:   rv = OpenIfaceFileStream(iface_name, getter_AddRefs(out));
• 313:   nsresult OpenIfaceFileStream(const char* aIfaceName,