自学教程：C++ CollCount函数代码示例

static void GetInputChar (void)/* Read the next character from the input stream and make CurC and NextC * valid. If end of line is reached, both are set to NUL, no more lines * are read by this function. */{    /* Drop all pushed fragments that don't have data left */    while (SB_GetIndex (Line) >= SB_GetLen (Line)) {        /* Cannot read more from this line, check next line on stack if any */        if (CollCount (&InputStack) == 0) {            /* This is THE line */            break;        }        FreeStrBuf (Line);        Line = CollPop (&InputStack);    }    /* Now get the next characters from the line */    if (SB_GetIndex (Line) >= SB_GetLen (Line)) {        CurC = NextC = '/0';    } else {        CurC = SB_AtUnchecked (Line, SB_GetIndex (Line));        if (SB_GetIndex (Line) + 1 < SB_GetLen (Line)) {            /* NextC comes from this fragment */            NextC = SB_AtUnchecked (Line, SB_GetIndex (Line) + 1);        } else {            /* NextC comes from next fragment */            if (CollCount (&InputStack) > 0) {                NextC = ' ';            } else {                NextC = '/0';            }        }    }}

static unsigned GetRegInfo1 (CodeSeg* S,                             CodeEntry* E,                             int Index,                             Collection* Visited,                             unsigned Used,                             unsigned Unused,                             unsigned Wanted)/* Recursively called subfunction for GetRegInfo. */{    /* Remember the current count of the line collection */    unsigned Count = CollCount (Visited);    /* Call the worker routine */    unsigned R = GetRegInfo2 (S, E, Index, Visited, Used, Unused, Wanted);    /* Restore the old count, unmarking all new entries */    unsigned NewCount = CollCount (Visited);    while (NewCount-- > Count) {        CodeEntry* E = CollAt (Visited, NewCount);        CE_ResetMark (E);        CollDelete (Visited, NewCount);    }    /* Return the registers used */    return R;}

void SegDump (void)/* Dump the segments and it's contents */{    unsigned I, J;    unsigned long Count;    unsigned char* Data;    for (I = 0; I < CollCount (&SegmentList); ++I) {        Segment* Seg = CollAtUnchecked (&SegmentList, I);        printf ("Segment: %s (%lu)/n", GetString (Seg->Name), Seg->Size);        for (J = 0; J < CollCount (&Seg->Sections); ++J) {            Section* S = CollAtUnchecked (&Seg->Sections, J);            unsigned J;            Fragment* F = S->FragRoot;            printf ("  Section:/n");            while (F) {                switch (F->Type) {                    case FRAG_LITERAL:                        printf ("    Literal (%u bytes):", F->Size);                        Count = F->Size;                        Data  = F->LitBuf;                        J = 100;                        while (Count--) {                            if (J > 75) {                                printf ("/n   ");                                J = 3;                            }                            printf (" %02X", *Data++);                            J += 3;                        }                        printf ("/n");                        break;                    case FRAG_EXPR:                        printf ("    Expression (%u bytes):/n", F->Size);                        printf ("    ");                        DumpExpr (F->Expr, 0);                        break;                    case FRAG_SEXPR:                        printf ("    Signed expression (%u bytes):/n", F->Size);                        printf ("      ");                        DumpExpr (F->Expr, 0);                        break;                    case FRAG_FILL:                        printf ("    Empty space (%u bytes)/n", F->Size);                        break;                    default:                        Internal ("Invalid fragment type: %02X", F->Type);                }                F = F->Next;            }        }    }}

static void ExecCmd (Collection* Args, const CmdEntry* Tab, unsigned Count)/* Search for the command in slot 0 of the given collection. If found, check * the argument count, then execute it. If there are problems, output a * diagnostic. */{    /* Search for the command, check number of args, then execute it */    const char* Cmd = CollAt (Args, 0);    const CmdEntry* E = FindCmd (Cmd, Tab, Count);    if (E == 0) {        PrintLine ("No such command: %s", Cmd);        return;    }    /* Check the number of arguments. Zero means that the function will check     * itself. A negative count means that the function needs at least     * abs(count) arguments. A positive count means that the function needs     * exactly this number of arguments.     * Note: The number includes the command itself.     */    if (E->ArgCount > 0 && (int)CollCount (Args) != E->ArgCount) {        /* Argument number mismatch */        switch (E->ArgCount) {            case 1:                PrintLine ("Command doesn't accept an argument");                return;            case 2:                PrintLine ("Command requires an argument");                return;            default:                PrintLine ("Command requires %d arguments", E->ArgCount-1);                return;        }    } else if (E->ArgCount < 0 && (int)CollCount (Args) < -E->ArgCount) {        /* Argument number mismatch */        switch (E->ArgCount) {            case -2:                PrintLine ("Command requires at least one argument");                return;            default:                PrintLine ("Command requires at least %d arguments", E->ArgCount-1);                return;        }    } else {        /* Remove the command from the argument list, then execute it */        CollDelete (Args, 0);        E->Func (Args);    }}

static void PrintO65Stats (const O65Data* D)/* Print information about the O65 file if --verbose is given */{    Print (stdout, 1, "Size of text segment:               %5lu/n", D->Header.tlen);    Print (stdout, 1, "Size of data segment:               %5lu/n", D->Header.dlen);    Print (stdout, 1, "Size of bss segment:                %5lu/n", D->Header.blen);    Print (stdout, 1, "Size of zeropage segment:           %5lu/n", D->Header.zlen);    Print (stdout, 1, "Number of imports:                  %5u/n", CollCount (&D->Imports));    Print (stdout, 1, "Number of exports:                  %5u/n", CollCount (&D->Exports));    Print (stdout, 1, "Number of text segment relocations: %5u/n", CollCount (&D->TextReloc));    Print (stdout, 1, "Number of data segment relocations: %5u/n", CollCount (&D->DataReloc));}

ExprNode* ULabRef (int Which)/* Get an unnamed label. If Which is negative, it is a backreference (a * reference to an already defined label), and the function will return a * segment relative expression. If Which is positive, it is a forward ref, * and the function will return a expression node for an unnamed label that * must be resolved later. */{    int     Index;    ULabel* L;    /* Which can never be 0 */    PRECONDITION (Which != 0);    /* Get the index of the referenced label */    if (Which > 0) {        --Which;    }    Index = (int) ULabDefCount + Which;    /* We cannot have negative label indices */    if (Index < 0) {        /* Label does not exist */        Error ("Undefined label");        /* We must return something valid */        return GenCurrentPC();    }    /* Check if the label exists. If not, generate enough forward labels. */    if (Index < (int) CollCount (&ULabList)) {        /* The label exists, get it. */        L = CollAtUnchecked (&ULabList, Index);    } else {        /* Generate new, undefined labels */        while (Index >= (int) CollCount (&ULabList)) {            L = NewULabel (0);        }    }    /* Mark the label as referenced */    ++L->Ref;    /* If the label is already defined, return its value, otherwise return     * just a reference.     */    if (L->Val) {        return CloneExpr (L->Val);    } else {        return GenULabelExpr (Index);    }}

void InsertObjGlobals (ObjData* O)/* Insert imports and exports from the object file into the global import and * export lists. */{    unsigned I;    /* Insert exports and imports */    for (I = 0; I < CollCount (&O->Exports); ++I) {        InsertExport (CollAt (&O->Exports, I));    }    for (I = 0; I < CollCount (&O->Imports); ++I) {        InsertImport (CollAt (&O->Imports, I));    }}

Collection* ParseAttrList (const char* List, const char** NameList, unsigned NameCount)/* Parse a list containing name/value pairs into a sorted collection. Some * attributes may not need a name, so NameList contains these names. If there * were no errors, the function returns a alphabetically sorted collection * containing Attr entries. */{    const char* Name;    /* Create a new collection */    Collection* C = NewCollection ();    /* Name/value pairs are separated by commas */    const char* L = List;    StrBuf B = AUTO_STRBUF_INITIALIZER;    while (1) {        if (*L == ',' || *L == ':' || *L == '/0') {            /* Terminate the string */            SB_Terminate (&B);            /* Determine the default name */            if (CollCount (C) >= NameCount) {                Name = 0;            } else {                Name = NameList[CollCount (C)];            }            /* Split and add this attribute/value pair */            SplitAddAttr (C, SB_GetConstBuf (&B), Name);            /* Done, clear the buffer. */            SB_Clear (&B);            if (*L == '/0') {                break;            }        } else {            SB_AppendChar (&B, *L);        }        ++L;    }    /* Free memory */    SB_Done (&B);    /* Return the collection with the attributes */    return C;}

static void CloseIncludeFile (void)/* Close an include file and switch to the higher level file. Set Input to * NULL if this was the main file. */{    AFile* Input;    /* Get the number of active input files */    unsigned AFileCount = CollCount (&AFiles);    /* Must have an input file when called */    PRECONDITION (AFileCount > 0);    /* Get the current active input file */    Input = (AFile*) CollLast (&AFiles);    /* Close the current input file (we're just reading so no error check) */    fclose (Input->F);    /* Delete the last active file from the active file collection */    CollDelete (&AFiles, AFileCount-1);    /* If we had added an extra search path for this AFile, remove it */    if (Input->SearchPath) {        PopSearchPath (UsrIncSearchPath);    }    /* Delete the active file structure */    FreeAFile (Input);}

void CS_DelLabel (CodeSeg* S, CodeLabel* L)/* Remove references from this label and delete it. */{    unsigned Count, I;    /* First, remove the label from the hash chain */    CS_RemoveLabelFromHash (S, L);    /* Remove references from insns jumping to this label */    Count = CollCount (&L->JumpFrom);    for (I = 0; I < Count; ++I) {       	/* Get the insn referencing this label */       	CodeEntry* E = CollAt (&L->JumpFrom, I);       	/* Remove the reference */       	CE_ClearJumpTo (E);    }    CollDeleteAll (&L->JumpFrom);    /* Remove the reference to the owning instruction if it has one. The     * function may be called for a label without an owner when deleting     * unfinished parts of the code. This is unfortunate since it allows     * errors to slip through.     */    if (L->Owner) {       	CollDeleteItem (&L->Owner->Labels, L);    }    /* All references removed, delete the label itself */    FreeCodeLabel (L);}

int IsBSSType (Segment* S)/* Check if the given segment is a BSS style segment, that is, it does not** contain non-zero data.*/{    /* Loop over all sections */    unsigned I;    for (I = 0; I < CollCount (&S->Sections); ++I) {        /* Get the next section */        Section* Sec = CollAtUnchecked (&S->Sections, I);        /* Loop over all fragments */        Fragment* F = Sec->FragRoot;        while (F) {            if (F->Type == FRAG_LITERAL) {                unsigned char* Data = F->LitBuf;                unsigned long Count = F->Size;                while (Count--) {                    if (*Data++ != 0) {                        return 0;                    }                }            } else if (F->Type == FRAG_EXPR || F->Type == FRAG_SEXPR) {                if (GetExprVal (F->Expr) != 0) {                    return 0;                }            }            F = F->Next;        }    }    return 1;}

void WriteAssertions (void)/* Write the assertion table to the object file */{    unsigned I;    /* Get the number of assertions */    unsigned Count = CollCount (&Assertions);    /* Tell the object file module that we're about to start the assertions */    ObjStartAssertions ();    /* Write the string count to the list */    ObjWriteVar (Count);    /* Write the assertions */    for (I = 0; I < Count; ++I) {        /* Get the next assertion */        Assertion* A = CollAtUnchecked (&Assertions, I);        /* Write it to the file */        WriteExpr (A->Expr);        ObjWriteVar ((unsigned) A->Action);        ObjWriteVar (A->Msg);        WriteLineInfo (&A->LI);    }    /* Done writing the assertions */    ObjEndAssertions ();}

static void SymReplaceExprRefs (SymEntry* S)/* Replace the references to this symbol by a copy of the symbol expression */{    unsigned I;    long     Val;    /* Check if the expression is const and get its value */    int IsConst = IsConstExpr (S->Expr, &Val);    CHECK (IsConst);    /* Loop over all references */    for (I = 0; I < CollCount (&S->ExprRefs); ++I) {        /* Get the expression node */        ExprNode* E = CollAtUnchecked (&S->ExprRefs, I);        /* Safety */        CHECK (E->Op == EXPR_SYMBOL && E->V.Sym == S);        /* We cannot touch the root node, since there are pointers to it.        ** Replace it by a literal node.        */        E->Op = EXPR_LITERAL;        E->V.IVal = Val;    }    /* Remove all symbol references from the symbol */    CollDeleteAll (&S->ExprRefs);}

static void ReadIndex (void)/* Read the index of a library file */{    unsigned Count, I;    /* Seek to the start of the index */    fseek (Lib, Header.IndexOffs, SEEK_SET);    /* Read the object file count and calculate the cross ref size */    Count = ReadVar (Lib);    /* Read all entries in the index */    while (Count--) {        ReadIndexEntry ();    }    /* Read basic object file data from the actual entries */    for (I = 0; I < CollCount (&ObjPool); ++I) {        /* Get the object file entry */        ObjData* O = CollAtUnchecked (&ObjPool, I);        /* Read data */        ObjReadData (Lib, O);    }}

char* SearchFile (const SearchPaths* P, const char* File)/* Search for a file in a list of directories. Return a pointer to a malloced** area that contains the complete path, if found, return 0 otherwise.*/{    char* Name = 0;    StrBuf PathName = AUTO_STRBUF_INITIALIZER;    /* Start the search */    unsigned I;    for (I = 0; I < CollCount (P); ++I) {        /* Copy the next path element into the buffer */        SB_CopyStr (&PathName, CollConstAt (P, I));        /* Add a path separator and the filename */        if (SB_NotEmpty (&PathName)) {            SB_AppendChar (&PathName, '/');        }        SB_AppendStr (&PathName, File);        SB_Terminate (&PathName);        /* Check if this file exists */        if (access (SB_GetBuf (&PathName), 0) == 0) {            /* The file exists, we're done */            Name = xstrdup (SB_GetBuf (&PathName));            break;        }    }    /* Cleanup and return the result of the search */    SB_Done (&PathName);    return Name;}

static Segment* NewSegFromDef (SegDef* Def)/* Create a new segment from a segment definition. Used only internally, no * checks. */{    /* Create a new segment */    Segment* S = xmalloc (sizeof (*S));    /* Initialize it */    S->Root      = 0;    S->Last      = 0;    S->FragCount = 0;    S->Num       = CollCount (&SegmentList);    S->Flags     = SEG_FLAG_NONE;    S->Align     = 1;    S->RelocMode = 1;    S->PC        = 0;    S->AbsPC     = 0;    S->Def       = Def;    /* Insert it into the segment list */    CollAppend (&SegmentList, S);    /* And return it... */    return S;}

void PrintDbgModules (FILE* F)/* Output the modules to a debug info file */{    unsigned I;    /* Output modules */    for (I = 0; I < CollCount (&ObjDataList); ++I) {        /* Get this object file */        const ObjData* O = CollConstAt (&ObjDataList, I);        /* The main source file is the one at index zero */        const FileInfo* Source = CollConstAt (&O->Files, 0);        /* Output the module line */        fprintf (F,                 "mod/tid=%u,name=/"%s/",file=%u",                 I,                 GetObjFileName (O),                 Source->Id);        /* Add library if any */        if (O->Lib != 0) {            fprintf (F, ",lib=%u", GetLibId (O->Lib));        }        /* Terminate the output line */        fputc ('/n', F);    }}

static void WriteDep (FILE* F, FileType Types)/* Helper function. Writes all file names that match Types to the output */{    unsigned I;    /* Loop over all files */    for (I = 0; I < CollCount (&FileTab); ++I) {        const StrBuf* Filename;        /* Get the next input file */        const FileEntry* E = (const FileEntry*) CollAt (&FileTab, I);        /* Ignore it if it is not of the correct type */        if ((E->Type & Types) == 0) {            continue;        }        /* If this is not the first file, add a space */        if (I > 0) {            fputc (' ', F);        }        /* Print the dependency */        Filename = GetStrBuf (E->Name);        fprintf (F, "%*s", SB_GetLen (Filename), SB_GetConstBuf (Filename));    }}

void SymLeaveLevel (void)/* Leave the current lexical level */{    /* If this is a scope that allows to emit data into segments, close the    ** open the spans.    */    if (CurrentScope->Type <= SCOPE_HAS_DATA) {        CloseSpanList (&CurrentScope->Spans);    }    /* If we have spans, the first one is the segment that was active, when the    ** scope was opened. Set the size of the scope to the number of data bytes    ** emitted into this segment. If we have an owner symbol set the size of    ** this symbol, too.    */    if (CollCount (&CurrentScope->Spans) > 0) {        const Span* S = CollAtUnchecked (&CurrentScope->Spans, 0);        unsigned long Size = GetSpanSize (S);        DefSizeOfScope (CurrentScope, Size);        if (CurrentScope->Label) {            DefSizeOfSymbol (CurrentScope->Label, Size);        }    }    /* Mark the scope as closed */    CurrentScope->Flags |= ST_CLOSED;    /* Leave the scope */    CurrentScope = CurrentScope->Parent;}

void UseSeg (const SegDef* D)/* Use the segment with the given name */{    unsigned I;    for (I = 0; I < CollCount (&SegmentList); ++I) {        Segment* Seg = CollAtUnchecked (&SegmentList, I);       	if (strcmp (Seg->Def->Name, D->Name) == 0) {     	    /* We found this segment. Check if the type is identical */	    if (D->AddrSize != ADDR_SIZE_DEFAULT &&                Seg->Def->AddrSize != D->AddrSize) {	 	Error ("Segment attribute mismatch");	 	/* Use the new attribute to avoid errors */	        Seg->Def->AddrSize = D->AddrSize;       	    }       	    ActiveSeg = Seg;     	    return;     	}    }    /* Segment is not in list, create a new one */    if (D->AddrSize == ADDR_SIZE_DEFAULT) {        ActiveSeg = NewSegment (D->Name, ADDR_SIZE_ABS);    } else {        ActiveSeg = NewSegment (D->Name, D->AddrSize);    }}

static void PrintUnresolved (ExpCheckFunc F, void* Data)/* Print a list of unresolved symbols. On unresolved symbols, F is** called (see the comments on ExpCheckFunc in the data section).*/{    unsigned I;    /* Print all open imports */    for (I = 0; I < ExpCount; ++I) {        Export* E = ExpPool [I];        if (E->Expr == 0 && E->ImpCount > 0 && F (E->Name, Data) == 0) {            /* Unresolved external */            Import* Imp = E->ImpList;            fprintf (stderr,                     "Unresolved external `%s' referenced in:/n",                     GetString (E->Name));            while (Imp) {                unsigned J;                for (J = 0; J < CollCount (&Imp->RefLines); ++J) {                    const LineInfo* LI = CollConstAt (&Imp->RefLines, J);                    fprintf (stderr,                         "  %s(%u)/n",                         GetSourceName (LI),                         GetSourceLine (LI));                }                Imp = Imp->Next;            }        }    }}

static void WriteDep (FILE* F, InputType Types)/* Helper function. Writes all file names that match Types to the output */{    unsigned I;    /* Loop over all files */    unsigned FileCount = CollCount (&IFiles);    for (I = 0; I < FileCount; ++I) {    	/* Get the next input file */    	const IFile* IF = (const IFile*) CollAt (&IFiles, I);        /* Ignore it if it is not of the correct type */        if ((IF->Type & Types) == 0) {            continue;        }    	/* If this is not the first file, add a space */       	if (I > 0) {            fputc (' ', F);        }    	/* Print the dependency escaping spaces */        WriteEscaped (F, IF->Name);    }}

static void AddNotifications (const Collection* LineInfos)/* Output additional notifications for an error or warning */{    unsigned I;    unsigned Output;    unsigned Skipped;    /* The basic line info is always in slot zero. It has been used to    ** output the actual error or warning. The following slots may contain    ** more information. Check them and print additional notifications if    ** they're present, but limit the number to a reasonable value.    */    for (I = 1, Output = 0, Skipped = 0; I < CollCount (LineInfos); ++I) {        /* Get next line info */        const LineInfo* LI = CollConstAt (LineInfos, I);        /* Check the type and output an appropriate note */        const char* Msg;        switch (GetLineInfoType (LI)) {        case LI_TYPE_ASM:            Msg = "Expanded from here";            break;        case LI_TYPE_EXT:            Msg = "Assembler code generated from this line";            break;        case LI_TYPE_MACRO:            Msg = "Macro was defined here";            break;        case LI_TYPE_MACPARAM:            Msg = "Macro parameter came from here";            break;        default:            /* No output */            Msg = 0;            break;        }        /* Output until an upper limit of messages is reached */        if (Msg) {            if (Output < MAX_NOTES) {                PrintMsg (GetSourcePos (LI), "Note", "%s", Msg);                ++Output;            } else {                ++Skipped;            }        }    }    /* Add a note if we have more stuff that we won't output */    if (Skipped > 0) {        const LineInfo* LI = CollConstAt (LineInfos, 0);        PrintMsg (GetSourcePos (LI), "Note",                  "Dropping %u additional line infos", Skipped);    }}

void WriteHLLDbgSyms (void)/* Write a list of all high level language symbols to the object file. */{    unsigned I;    /* Only if debug info is enabled */    if (DbgSyms) {        /* Write the symbol count to the list */        ObjWriteVar (CollCount (&HLLDbgSyms));        /* Walk through list and write all symbols to the file. */        for (I = 0; I < CollCount (&HLLDbgSyms); ++I) {            /* Get the next symbol */            HLLDbgSym* S = CollAtUnchecked (&HLLDbgSyms, I);            /* Get the type of the symbol */            unsigned SC = HLL_GET_SC (S->Flags);            /* Remember if the symbol has debug info attached            ** ### This should go into DbgInfoCheck            */            if (S->Sym && S->Sym->DebugSymId != ~0U) {                S->Flags |= HLL_DATA_SYM;            }            /* Write the symbol data */            ObjWriteVar (S->Flags);            ObjWriteVar (S->Name);            if (HLL_HAS_SYM (S->Flags)) {                ObjWriteVar (S->Sym->DebugSymId);            }            if (SC == HLL_SC_AUTO || SC == HLL_SC_REG) {                ObjWriteVar (S->Offs);            }            ObjWriteVar (S->Type);            ObjWriteVar (S->Scope->Id);        }    } else {        /* Write a count of zero */        ObjWriteVar (0);    }}

static void ConvertImports (FILE* F, const O65Data* D)/* Convert the imports */{    unsigned I;    if (CollCount (&D->Imports) > 0) {        for (I = 0; I < CollCount (&D->Imports); ++I) {            /* Get the next import */            const O65Import* Import = CollConstAt (&D->Imports, I);            /* Import it by name */            fprintf (F, ".import/t%s/n", Import->Name);        }        fprintf (F, "/n");    }}

char* GetSearchPath (SearchPaths* P, unsigned Index)/* Return the search path at the given index, if the index is valid, return an** empty string otherwise.*/{    if (Index < CollCount (P))        return CollAtUnchecked (P, Index);    return "";}

struct DbgSym* GetObjDbgSym (const ObjData* O, unsigned Id)/* Get a debug symbol from an object file checking for a valid index */{    if (Id >= CollCount (&O->DbgSyms)) {        Error ("Invalid debug symbol index (%u) in module `%s'",               Id, GetObjFileName (O));    }    return CollAtUnchecked (&O->DbgSyms, Id);}

struct Export* GetObjExport (const ObjData* O, unsigned Id)/* Get an export from an object file checking for a valid index */{    if (Id >= CollCount (&O->Exports)) {        Error ("Invalid export index (%u) in module `%s'",               Id, GetObjFileName (O));    }    return CollAtUnchecked (&O->Exports, Id);}

struct Scope* GetObjScope (const ObjData* O, unsigned Id)/* Get a scope from an object file checking for a valid index */{    if (Id >= CollCount (&O->Scopes)) {        Error ("Invalid scope index (%u) in module `%s'",               Id, GetObjFileName (O));    }    return CollAtUnchecked (&O->Scopes, Id);}

const char* GetCurrentFile (void)/* Return the name of the current input file */{    unsigned AFileCount = CollCount (&AFiles);    if (AFileCount > 0) {     	const AFile* AF = (const AFile*) CollAt (&AFiles, AFileCount-1);     	return AF->Input->Name;    } else {     	/* No open file. Use the main file if we have one. */     	unsigned IFileCount = CollCount (&IFiles);     	if (IFileCount > 0) {     	    const IFile* IF = (const IFile*) CollAt (&IFiles, 0);     	    return IF->Name;     	} else {      	    return "(outside file scope)";     	}    }}