示例#1
0
文件: macro.c 项目: collects/me
int	
helpCommand(int f, int n)
{
    meUByte *ss, buf[meBUF_SIZE_MAX] ;
              
    if(meGetString((meUByte *)"Help on command", MLCOMMAND, 0, buf, meBUF_SIZE_MAX-10) <= 0)
        return false ;
    ss = buf + meStrlen(buf) ;
    meStrcpy(ss,"(2)") ;
    if(findHelpItem(buf,1) > 0)
        return true ;
    meStrcpy(ss,"(3)") ;
    return findHelpItem(buf,0) ;
}
示例#2
0
文件: macro.c 项目: collects/me
int
insMacro(int f, int n)
{
    meWindow          *wp ;
    register meLine   *lp, *slp ;
    meMacro         *mac ;
    meUByte            buf[meBUF_SIZE_MAX] ;
    meInt            nol, lineNo, len ;
    int              ii ;
    
    meStrcpy(buf,"define-macro ") ;
    if((mac=userGetMacro(buf+13, meBUF_SIZE_MAX-13)) == NULL)
        return false ;
    
    if((ii=bufferSetEdit()) <= 0)               /* Check we can change the buffer */
        return ii ;
    frameCur->windowCur->dotOffset = 0 ;
    slp = frameCur->windowCur->dotLine ;
    lineNo = frameCur->windowCur->dotLineNo ;
    nol = addLine(slp,buf) ;
    len = meStrlen(buf) + 9 ;
    lp = meLineGetNext(mac->hlp);            /* First line.          */
    while (lp != mac->hlp)
    {
        nol += addLine(slp,lp->text) ;
        len += meLineGetLength(lp) + 1 ;
        lp = meLineGetNext(lp);
    }
    nol += addLine(slp,(meUByte *)"!emacro") ;
    frameCur->bufferCur->lineCount += nol ;
    meFrameLoopBegin() ;
    for (wp=loopFrame->windowList; wp!=NULL; wp=wp->next)
    {
        if (wp->buffer == frameCur->bufferCur)
        {
            if(wp->dotLineNo >= lineNo)
                wp->dotLineNo += nol ;
            if(wp->markLineNo >= lineNo)
                wp->markLineNo += nol ;
            wp->updateFlags |= WFMAIN|WFMOVEL ;
        }
    }
    meFrameLoopEnd() ;
#if MEOPT_UNDO
    meUndoAddInsChars(len) ;
#endif
    return true ;
}
示例#3
0
/*
 * rnodeNew
 * Allocate and initialise a new node
 */
static meRegNode *
rnodeNew (meUByte *name)
{
    meRegNode *np;                          /* Pointer to the node */
    int len;                            /* Length of the string */

    /* Get the length of the node name */
    len = meStrlen(name) ;

    /* Allocate space for the node and copy in the node name */
    if ((np = (meRegNode *) meMalloc(sizeof(meRegNode) + len)) == NULL)
        return NULL;
    memset(np, 0, sizeof(meRegNode));
    meStrcpy(np->name,name) ;
    return (np);
}
示例#4
0
文件: macro.c 项目: collects/me
int
stringExec(int f, int n, meUByte *macro)
{
    meUByte *okbdptr;
    meUByte  oldcle ;      /* old contents of clexec flag */
    meUByte *oldestr ;	 /* original exec string */
    int  okbdlen, okbdoff, okbdmode, okbdrep ;
    int  oldexec, ii ;
    
    okbdptr = kbdptr ;
    okbdoff = kbdoff ;
    okbdlen = kbdlen ;
    okbdrep = kbdrep ;
    okbdmode = kbdmode ;
    oldcle = clexec;			/* save old clexec flag */
    clexec = false;			/* in cline execution */
    oldestr = execstr;	/* save last ptr to string to execute */
    execstr = NULL ;
    oldexec = execlevel ;
    execlevel = 0;			/* Reset execution level */
    
    kbdptr = macro ;
    kbdoff = 0 ;
    kbdlen = meStrlen(macro) ;
    kbdrep = n ;
    kbdmode = mePLAY;     /* start us in play mode */
    ii = true ;
    while((kbdrep > 1) || (kbdoff < kbdlen))
    {
        if(TTbreakFlag || (kbdmode != mePLAY))
        {
            ii = meABORT ;
            break ;
        }
        doOneKey() ;
    }
    kbdptr = okbdptr ;
    kbdoff = okbdoff ;
    kbdlen = okbdlen ;
    kbdrep = okbdrep ;
    kbdmode = okbdmode ;
    execlevel = oldexec ;
    clexec = oldcle;			/* restore clexec flag */
    execstr = oldestr;
    
    return ii ;
}
示例#5
0
void
meUndoAddReplace(meUByte *dstr, meInt count)
{
    if(meModeTest(frameCur->bufferCur->mode,MDUNDO))
    {
        meUndoCoord *co ;
        meUndoNode    *nn ;
        int        doto, contFlag ;

        contFlag = (frameCur->bufferCur->undoContFlag == undoContFlag) ;

        nn = frameCur->bufferCur->undoHead ;
        if((nn == NULL) || !meUndoIsReplace(nn) ||
           (nn->count != count) || (nn->doto == 0xffff) ||
           meStrcmp(nn->str,dstr))
        {
            meUByte *dd ;
            if((nn = meUndoCreateNode(sizeof(meUndoNode)+meStrlen(dstr))) == NULL)
                return ;
            nn->type |= meUNDO_DELETE|meUNDO_INSERT|meUNDO_REPLACE ;
            nn->udata.pos = NULL ;
            nn->doto = 0 ;
            nn->count = count ;
            dd = nn->str ;
            while((*dd++ = *dstr++))
                ;
        }
        /* replace is the same as last time */
        if(!(nn->doto & 0x0f) &&
           ((nn->udata.pos = meRealloc(nn->udata.pos,sizeof(meUndoCoord)*
                                       (nn->doto+16))) == NULL))
            return ;
        co = nn->udata.pos ;
        doto = frameCur->windowCur->dotOffset ;
        if(contFlag)
            /* sub 1 of so 0 becomes less than 0 */
            doto = -1 - doto ;
        co[nn->doto][0]   = frameCur->windowCur->dotLineNo ;
        co[nn->doto++][1] = doto ;
        frameCur->bufferCur->undoContFlag = undoContFlag ;
    }
}
示例#6
0
文件: macro.c 项目: collects/me
static int
findHelpItem(meUByte *item, int silent)
{
    meWindow *wp ;
    meBuffer *bp, *hbp ;
    meLine   *lp, *elp ;
    int     sectLen, itemLen, ii ;
    meUByte  *ss, cc, sect[5] ;
    
    itemLen = meStrlen(item) ;
    if((item[itemLen-1] == ')') &&
       ((item[(ii=itemLen-3)] == '(') ||
        (item[(ii=itemLen-4)] == '(') ))
    {
        sectLen = itemLen-ii-2 ;
        meStrcpy(sect,item+ii) ;
        itemLen = ii ;
        item[itemLen] = '\0' ;
    }
    else
    {
        sectLen = 0 ;
        sect[0] = '\0' ;
        sect[1] = '\0' ;
    }
	
    if((hbp=helpBufferFind()) == NULL)
        return meABORT ;
    elp = hbp->baseLine ;
try_again:
    lp = meLineGetNext(elp) ;
    while(lp != elp)
    {
        if((lp->text[0] == '!') &&
           (!sectLen || 
            ((sect[1] == lp->text[2]) &&
             (((sectLen == 1) && (lp->text[3] == ' ')) || 
              (sect[2] == lp->text[3])))))
        {
            if((cc=lp->text[1]) == ' ')
            {
                ii = meLineGetLength(lp) - 4 ;
                if(ii != itemLen)
                    ii = -1 ;
            }
            else
            {
                ii = cc - '0' ;
                if(ii > itemLen)
                    ii = -1 ;
            }
            if((ii > 0) && !meStrncmp(item,lp->text+4,ii))
                break ;
        }
        lp = meLineGetNext(lp) ;
    }
        
    if(lp == elp)
    {
        meMacro *mac ;
        if(!meModeTest(hbp->mode,MDLOCK))
        {
            if(helpBufferLoad(hbp) == meABORT)
                return meABORT ;
            goto try_again ;
        }
        if((getMacroTypeS(item) == TKCMD) &&
           ((ii = decode_fncname(item,1)) >= CK_MAX) &&
           ((mac = getMacro(ii)) != NULL) &&
           (mac->hlp->flag & meMACRO_FILE))
        {
            meModeClear(hbp->mode,MDVIEW) ;
            if(mac->fname != NULL)
                execFile(mac->fname,0,1) ;
            else
                execFile(mac->name,0,1) ;
            helpBufferReset(hbp) ;
            if(!(mac->hlp->flag & meMACRO_FILE))
                goto try_again ;
        }
        if(!silent)
            mlwrite(MWABORT,(meUByte *)"[Can't find help on %s%s]",item,sect);
        return meABORT ;
    }
    if((wp = meWindowPopup(BhelpN,BFND_CREAT|BFND_CLEAR|WPOP_USESTR,NULL)) == NULL)
        return false ;
    if((sectLen == 0) && (lp->text[2] != ' '))
    {
        ss = sect ;
        *ss++ = '(' ;
        *ss++ = lp->text[2] ;
        if(lp->text[3] != ' ')
            *ss++ = lp->text[3] ;
        *ss++ = ')' ;
        *ss = '\0' ;
    }
    
    bp = wp->buffer ;
    /* Add the header */
    {
        meUByte buff[meBUF_SIZE_MAX] ;
        sprintf((char *)buff,"\033cD%s%s\033cA",lp->text+4,sect) ;
        addLineToEob(bp,buff) ;
        addLineToEob(bp,(meUByte *)"\n\033lsMicroEmacs\033lm[Home]\033le \033lsCommand G\033lm[Commands]\033le \033lsVariable \033lm[Variables]\033le \033lsMacro Lan\033lm[Macro-Dev]\033le \033lsGlobal G\033lm[Glossary]\033le") ;
        memset(buff,boxChars[BCEW],78) ;
        buff[78] = '\n' ;
        buff[79] = '\0' ;
        addLineToEob(bp,buff) ;
    }
    while(((lp=meLineGetNext(lp)) != elp) && (lp->text[0] == '!'))
        ;
    while((lp != elp) && ((cc=lp->text[0]) != '!'))
    {
        if(cc == '|')
        {
            if(meStrcmp(item,lp->text+1))
                lp = meLineGetNext(lp) ;
        }
        else if(cc == '$')
        {
            if(lp->text[1] == 'a')
            {
                if(sect[1] == '5')
                {
                    meUByte line[meBUF_SIZE_MAX], *ss ;
                    if((ss = getval(item)) != NULL)
                    {
                        addLineToEob(bp,(meUByte *)"\n\n\033cEVALUE\033cA\n") ;
                        meStrcpy(line,"    \"") ;
                        meStrncpy(line+5,ss,meBUF_SIZE_MAX-13) ;
                        line[meBUF_SIZE_MAX-2] = '\0' ;
                        meStrcat(line,"\"") ;
                        addLineToEob(bp,line) ;
                    }
                }
                if(sect[1] == '2')
                {
                    if((ii = decode_fncname(item,1)) >= 0)
                    {
                        meBind *ktp ;
                        meUByte line[meBUF_SIZE_MAX], *ss ;
                        addLineToEob(bp,(meUByte *)"\n\n\033cEBINDINGS\033cA\n") ;
                        meStrcpy(line,"    ") ;
                        ss = line+4 ;
                        for(ktp = &keytab[0] ; ktp->code != ME_INVALID_KEY ; ktp++)
                        {
                            if(ktp->index == ii)
                            {
                                *ss++ = '"' ;
                                meGetStringFromKey(ktp->code,ss);
                                ss += meStrlen(ss) ;
                                *ss++ = '"' ;
                                *ss++ = ' ' ;
                            }
                        }
                        if(ss == line+4)
                            meStrcpy(ss,"none") ;
                        else
                            *ss = '\0' ;
                        addLineToEob(bp,line) ;
                    }
                }
            }
        }
        else
            addLineToEob(bp,lp->text) ;
        lp = meLineGetNext(lp) ;
    }
    /* Add the footer */
    {
        meUByte buff[meBUF_SIZE_MAX] ;
        buff[0] = '\n' ;
        memset(buff+1,boxChars[BCEW],78) ;
        sprintf((char *)buff+79,"\n\033lsCopyright\033lm%s\033le",meCopyright) ;
        addLineToEob(bp,buff) ;
    }
    bp->dotLine = meLineGetNext(bp->baseLine);
    bp->dotOffset = 0 ;
    bp->dotLineNo = 0 ;
    meModeClear(bp->mode,MDEDIT) ;    /* don't flag this as a change */
    meModeSet(bp->mode,MDVIEW) ;      /* put this buffer view mode */
    resetBufferWindows(bp) ;            /* Update the window */
    mlerase(MWCLEXEC);	                /* clear the mode line */
    return true ;
}
示例#7
0
void
meSetupPathsAndUser(char *progname)
{
    meUByte *ss, buff[meBUF_SIZE_MAX] ;
    int ii, ll, gotUserPath ;
    
    curdir = gwd(0) ;
    if(curdir == NULL)
        /* not yet initialised so mlwrite will exit */
        mlwrite(MWCURSOR|MWABORT|MWWAIT,(meUByte *)"Failed to get cwd\n") ;
    
    /* setup the $progname make it an absolute path. */
    if(executableLookup(progname,evalResult))
        meProgName = meStrdup(evalResult) ;
    else
    {
#ifdef _ME_FREE_ALL_MEMORY
        /* stops problems on exit */
        meProgName = meStrdup(progname) ;
#else
        meProgName = (meUByte *)progname ;
#endif
    }
    
#if MEOPT_BINFS
    /* Initialise the built-in file system. Note for speed we only check the
     * header. Scope the "exepath" locally so it is discarded once the
     * pathname is passed to the mount and we exit the braces. */
    bfsdev = bfs_mount (meProgName, BFS_CHECK_HEAD);
#endif
    
    if(meUserName == NULL)
    {
        if(((ss = meGetenv ("MENAME")) == NULL) || (ss[0] == '\0'))
            ss = "user" ;
        meUserName = meStrdup(ss) ;
    }
    
    /* get the users home directory, user path and search path */
    if(((ss = meGetenv("HOME")) == NULL) || (ss[0] == '\0'))
        ss = "c:/" ;
    fileNameSetHome(ss) ;

    if(((ss = meGetenv ("MEUSERPATH")) != NULL) && (ss[0] != '\0'))
        meUserPath = meStrdup(ss) ;
    
    if(((ss = meGetenv("MEPATH")) != NULL) && (ss[0] != '\0'))
    {
        /* explicit path set by the user, don't need to look at anything else */
        searchPath = meStrdup(ss) ;
        /* we just need to add the $user-path to the front */
        if(meUserPath != NULL)
        {
            /* check that the user path is first in the search path, if not add it */
            ll = meStrlen(meUserPath) ;
            if(meStrncmp(searchPath,meUserPath,ll) ||
               ((searchPath[ll] != '\0') && (searchPath[ll] != mePATH_CHAR)))
            {
                /* meMalloc will exit if it fails as ME has not finished initialising */
                ss = meMalloc(ll + meStrlen(searchPath) + 2) ;
                meStrcpy(ss,meUserPath) ;
                ss[ll] = mePATH_CHAR ;
                meStrcpy(ss+ll+1,searchPath) ;
                meFree(searchPath) ;
                searchPath = ss ;
            }
        }
    }
    else
    {
        /* construct the search-path */
        /* put the $user-path first */
        if((gotUserPath = (meUserPath != NULL)))
            meStrcpy(evalResult,meUserPath) ;
        else
            evalResult[0] = '\0' ;
        ll = meStrlen(evalResult) ;
        
        /* look for the ~/jasspa directory */
        if(homedir != NULL)
        {
            meStrcpy(buff,homedir) ;
            meStrcat(buff,"jasspa") ;
            if(((ll = mePathAddSearchPath(ll,evalResult,buff,&gotUserPath)) > 0) && !gotUserPath)
                /* as this is the user's area, use this directory unless we find
                 * a .../<$user-name>/ directory */
                gotUserPath = -1 ;
        }
        
        /* Get the system path of the installed macros. Use $MEINSTPATH as the
         * MicroEmacs standard macros */
        if(((ss = meGetenv ("MEINSTALLPATH")) != NULL) && (ss[0] != '\0'))
        {
            meStrcpy(buff,ss) ;
            ll = mePathAddSearchPath(ll,evalResult,buff,&gotUserPath) ;
        }
        
        /* also check for directories in the same location as the binary */
        if((meProgName != NULL) && ((ss=meStrrchr(meProgName,DIR_CHAR)) != NULL))
        {
            ii = (((size_t) ss) - ((size_t) meProgName)) ;
            meStrncpy(buff,meProgName,ii) ;
            buff[ii] = '\0' ;
            ll = mePathAddSearchPath(ll,evalResult,buff,&gotUserPath) ;
        }
        if(!gotUserPath && (homedir != NULL))
        {
            /* We have not found a user path so set ~/ as the user-path
             * as this is the best place for macros to write to etc. */
            meStrcpy(buff,homedir) ;
            if(ll)
            {
                ii = meStrlen(buff) ;
                buff[ii++] = mePATH_CHAR ;
                meStrcpy(buff+ii,evalResult) ;
            }
            searchPath = meStrdup(buff) ;
        }
        else if(ll > 0)
            searchPath = meStrdup(evalResult) ;
    }
    if(searchPath != NULL)
    {
        fileNameConvertDirChar(searchPath) ;
        if(meUserPath == NULL)
        {
            /* no user path yet, take the first path from the search-path, this
             * should be a sensible directory to use */
            if((ss = meStrchr(searchPath,mePATH_CHAR)) != NULL)
                *ss = '\0' ;
            meUserPath = meStrdup(searchPath) ;
            if(ss != NULL)
                *ss = mePATH_CHAR ;
        }
    }
    if(meUserPath != NULL)
    {
        fileNameConvertDirChar(meUserPath) ;
        ll = meStrlen(meUserPath) ;
        if(meUserPath[ll-1] != DIR_CHAR)
        {
            meUserPath = meRealloc(meUserPath,ll+2) ;
            meUserPath[ll++] = DIR_CHAR ;
            meUserPath[ll] = '\0' ;
        }
    }
}
示例#8
0
/*
 * regRead
 * Open the specified registory.
 * Mode options are:-
 *
 * default        - Exists in memory
 * meREGMODE_RELOAD - Delete the existing file,
 * meREGMODE_MERGE  - Merge the existing file.
 */
meRegNode *
regRead(meUByte *rname, meUByte *fname, int mode)
{
    meLine hlp, *lp ;
    meUByte *fn ;
    meRegNode *rnp;                         /* Root node pointer */
    meUInt flags ;
    
    /* Find the registry entry */
    if(*rname == '/')
        rname++;
    if ((rnp = rnodeFind (&root, rname)) != NULL)
    {
        /* if not merging or reloading then we've can use the existing node */
        if (!(mode & (meREGMODE_MERGE|meREGMODE_RELOAD)))
            goto finished;
        fn = rnp->value ;
    }
    else
        fn = NULL ;
    
    if(mode & meREGMODE_FROOT)
    {
        /* find the registry file */
        /* have we been given a valid file name ? */
        if ((fname != NULL) && (fname [0] != '\0'))
        {
            meUByte filename[meBUF_SIZE_MAX] ;	/* Filename */
            if(fileLookup(fname,(meUByte *)".erf",meFL_CHECKDOT|meFL_USESRCHPATH,filename))
                fn = meStrdup(filename) ;
            else
                fn = meStrdup(fname) ;
        }
        /* else use the old file name (if there is one) else fail */
        else if(fn == NULL)
        {
            mlwrite(MWABORT|MWWAIT,(meUByte *)"[No file name given to load]") ;
            return NULL ;
        }
    
        /* Load in the registry file */
        flags = meRWFLAG_SILENT ;
        hlp.next = &hlp ;
        hlp.prev = &hlp ;
        if(mode & meREGMODE_CRYPT)
        {
            meUByte s1[meBUF_SIZE_MAX], *s2 ;
            int len ;
            meCrypt(NULL,0);
            meStrcpy(s1,getFileBaseName(fn)) ;
            len = meStrlen(s1) + 1 ;
            meCrypt(s1,len) ;
            if((s2=meUserName) == NULL)
                s2 = (meUByte *) "" ;
            meStrcpy(s1+len,s2) ;
            meCrypt(s1,len+meStrlen(s1+len)+1) ;
            flags |= meRWFLAG_CRYPT ;
        }
        if((ffReadFile(fn,flags,NULL,&hlp,0,0,0) == meABORT) &&
           !(mode & meREGMODE_CREATE))
        {
            mlwrite (MWABORT|MWWAIT,(meUByte *)"[Cannot load registry file %s]", fname);
            return NULL ;
        }
        lp = &hlp ;
    }
    else
        lp = frameCur->bufferCur->baseLine ;
    
    if ((rnp != NULL) && (mode & meREGMODE_RELOAD))
    {
        /* Want to replace with new one. so delete old */
        if(fn == rnp->value)
            rnp->value = NULL ;
        rnodeUnlink (rnp);
        rnodeDelete (rnp);
        rnp = NULL;
    }
    /* Construct the node for the file node */
    if (rnp == NULL)
    {
        /* Construct the node */
        if((rnp = regSet (&root, rname, NULL)) == NULL)
            return NULL ;
        rnp->mode = 0;
    }
    /* set the new file name */
    if(rnp->value != fn)
    {
        meNullFree(rnp->value) ;
        rnp->value = fn ;
    }
    /* Now parse the registry file */
    parseFile(rnp, lp) ;
    
    if(mode & meREGMODE_FROOT)
        meLineLoopFree(lp,0) ;

finished:
    rnp->mode |= mode & meREGMODE_STORE_MASK ;
    return rnp ;
}
示例#9
0
/*
 * regSave
 * Save the registry back to file
 */
int
regSave(meRegNode *rnp, meUByte *fname, int mode)
{
    meRegNode *rr ;
    meInt ss=meTRUE, level=0, lineCount, charCount ;
    meUInt flags ;

    if(mode & meREGMODE_FROOT)
    {
        /* Find the filename */
        if ((fname == NULL) || (fname[0] == '\0'))
        {
            fname = NULL;
            if(rnp->mode & meREGMODE_FROOT)
                fname = rnp->value;        /* Use the default file name */
            if(fname == NULL)
                return mlwrite(MWABORT|MWPAUSE,(meUByte *)"Registry: No file name specified on save");
        }
        flags = meRWFLAG_WRITE ;
        if(mode & meREGMODE_BACKUP)
            flags |= meRWFLAG_BACKUP ;
        if(mode & meREGMODE_CRYPT)
        {
            meUByte s1[meBUF_SIZE_MAX], *s2 ;
            int len ;
            meCrypt(NULL,0);
            meStrcpy(s1,getFileBaseName(fname)) ;
            len = meStrlen(s1) + 1 ;
            meCrypt(s1,len) ;
            if((s2=meUserName) == NULL)
                s2 = (meUByte *) "" ;
            meStrcpy(s1+len,s2) ;
            meCrypt(s1,len+meStrlen(s1+len)+1) ;
            flags |= meRWFLAG_CRYPT ;
        }
        /* Open the file */
        if(ffWriteFileOpen(fname,flags,NULL) <= 0)
            return meABORT ;
        
        /* Add a recognition string to the header */
        if(!(mode & meREGMODE_CRYPT))
            ss = ffWriteFileWrite(12,(meUByte *) ";-!- erf -!-",1) ;
    }
    else
    {
        mode &= ~meREGMODE_CRYPT ;
        lineCount = 0 ;
        charCount = 0 ;
    }
    
    /* Recurse the children of the node and write to file */
    rr = rnp->child ;
    while((ss > 0) && (rr != NULL))
    {
        meUByte buff[4096] ;
        int  len ;
        /* Print the node */
        if((len = level) != 0)
            memset(buff,' ',len) ;
        buff[len++] = '"' ;
        len = expandexp(-1,rr->name,4096-11,len,buff,-1,NULL,meEXPAND_BACKSLASH|meEXPAND_FFZERO|meEXPAND_PRINTABLE) ;
        buff[len++] = '"' ;
        if (rr->mode & (meREGMODE_HIDDEN|meREGMODE_INTERNAL))
        {
            buff[len++] = ' ' ;
            buff[len++] = '0' + (rr->mode & (meREGMODE_HIDDEN|meREGMODE_INTERNAL)) ;
        }
        if (rr->value != NULL)
        {
            buff[len++] = ' ' ;
            buff[len++] = '=' ;
            buff[len++] = ' ' ;
            buff[len++] = '"' ;
            len = expandexp(-1,rr->value,4096-4,len,buff,-1,NULL,meEXPAND_BACKSLASH|meEXPAND_FFZERO|meEXPAND_PRINTABLE) ;
            buff[len++] = '"' ;
        }
        /* write open '{' if it has children */
        if (rr->child != NULL)
        {
            buff[len++] = ' ' ;
            buff[len++] = '{' ;
        }
        if((mode & meREGMODE_FROOT) == 0)
        {
            buff[len] = '\0' ;
            if((ss = addLine(frameCur->windowCur->dotLine,buff)) <= 0)
                break ;
            lineCount += ss ;
            charCount += len + 1 ;
        }
        else if((ss = ffWriteFileWrite(len,buff,1)) <= 0)
            break ;
        /* Descend child */
        if (rr->child != NULL)
        {
            rr = rr->child;
            level++;
            continue;
        }
        /* Ascend the tree */
        for (;;)
        {
            /* Move to sibling */
            if (rr->next != NULL)
            {
                rr = rr->next;
                break;
            }
            
            if (rr->parent != NULL)
            {
                if (--level < 0)
                {
                    rr = NULL;
                    break;
                }
                rr = rr->parent;
                /* as we are assending the tree, at least the first 'level'
                 * number of chars in buffer must be ' 's so just splat in the '}'
                 */
                len = level ;
                buff[len++] = '}' ;
                if((mode & meREGMODE_FROOT) == 0)
                {
                    buff[len] = '\0' ;
                    if((ss = addLine(frameCur->windowCur->dotLine,buff)) <= 0)
                        break ;
                    lineCount += ss ;
                    charCount += len + 1 ;
                }
                else if((ss = ffWriteFileWrite(len,buff,1)) <= 0)
                    break ;
            }
        }
    }
    
    if(mode & meREGMODE_FROOT)
    {
        if(ffWriteFileClose(fname,meRWFLAG_WRITE,NULL) <= 0)
            return meABORT ;
        rnp->mode &= ~meREGMODE_CHANGE;
    }
    else
    {
        meWindow *wp ;
        level = frameCur->windowCur->dotLineNo ;
        frameCur->bufferCur->lineCount += lineCount ;
        meFrameLoopBegin() ;
        for(wp=loopFrame->windowList; wp!=NULL; wp=wp->next)
        {
            if (wp->buffer == frameCur->bufferCur)
            {
                if(wp->dotLineNo >= level)
                    wp->dotLineNo += lineCount ;
                if(wp->markLineNo >= level)
                    wp->markLineNo += lineCount ;
                wp->updateFlags |= WFMAIN|WFMOVEL ;
            }
        }
        meFrameLoopEnd() ;
        frameCur->windowCur->dotOffset = 0 ;
#if MEOPT_UNDO
        meUndoAddInsChars(charCount) ;
#endif
        if(ss <= 0)
            return mlwrite(MWABORT|MWPAUSE,(meUByte *)"[Failed to write registry %s]",fname) ;
    }
    return meTRUE ;
}