C++ printf2函数代码示例

void HIDDEN GetAddressVtableByClassname(const char *szClassName, const int iOffset, bool bCreate)
{
	void *vtable;

	if (bCreate)
	{
		edict_t *pObject = CREATE_ENTITY();

		void *addr = GetFunctionEntity(szClassName);
	
		if (addr == NULL)
		{
			//can't create object. 
			printf2(__FUNCTION__ ":: Not found export function of binaries. Presumably looks '__declspec(dllexport) void %s(entvars_t *pev)'", szClassName);
			REMOVE_ENTITY(pObject);
			return;
		}

		// call link to class GetClassPtr<BaseClass>(pev);
		reinterpret_cast<void (*)(entvars_t *)>(addr)(&pObject->v);

		vtable = *(void **)pObject->pvPrivateData;
	}
	else
	{
		VirtualTableRef *refsVtbl = GetVirtualTableRefAddr(szClassName);
		vtable = (void *)refsVtbl->originalAddress;
	}

	printf2(__FUNCTION__ "* ADDRESS VTABLE: %p | ADDRESS VIRTUAL FUNC: %p",
		OffsetToRebase((size_t)vtable),
		OffsetToRebase(*(((size_t **)&vtable)[ iOffset ])));
}

void GenLabel(char* Label, int Static)
{
  {
    if (OutputFormat != FormatFlat && !Static && GenExterns)
      printf2("\t.globl\t%s\n", Label);
    printf2("%s:\n", Label);
  }
}

STATIC
void GenLabel(char* Label, int Static)
{
  {
    if (!Static && GenExterns)
      printf2("\t.global\t_%s\n", Label);
    printf2("_%s:\n", Label);
  }
}

void GenPrintLabel(char* Label)
{
  {
    if (isdigit(*Label))
      printf2("$L%s", Label);
    else
      printf2("%s", Label);
  }
}

STATIC
void GenPrintLabel(char* Label)
{
  {
    if (isdigit(*Label))
      printf2("L%s", Label);
    else
      printf2("_%s", Label);
  }
}

void GenAddrData(int Size, char* Label)
{
  if (Size == 1)
    printf2("\t.byte\t");
  else if (Size == 2)
    printf2("\t.half\t");
  else if (Size == 4)
    printf2("\t.word\t");
  GenPrintLabel(Label); puts2("");
}

void GenIntData(int Size, int Val)
{
  Val = truncInt(Val);
  if (Size == 1)
    printf2("\t.byte\t%d\n", Val);
  else if (Size == 2)
    printf2("\t.half\t%d\n", Val);
  else if (Size == 4)
    printf2("\t.word\t%d\n", Val);
}

STATIC
void GenIntData(int Size, int Val)
{
  Val = truncInt(Val);
  if (Size == 1)
    printf2("\t.db\t%d\n", Val);
  else if (Size == 2)
    printf2("\t.dw\t%d\n", Val);
  else if (Size == 4)
    printf2("\t.dd\t%d\n", Val);
}

__MSSHELL_WRAPPER_ __WINCALL static void _MS__private __system colFileLoader(const sel_typ argc, char ** argv)
{
    char path[MAX_PATH_LENGTH];
    #ifdef WINOS
		if(isnSett(BOOLS_ITEMSSELECTBYPATH))
		{
		    const bool wHandler = windowsFileHandler(path,  "Settings Configuration (*."DEFAULT_COLORS_FILE_EXTENSION")\0*."DEFAULT_COLORS_FILE_EXTENSION"\0Text Documents (*.txt)\0*.txt\0All Files (*.*)\0*.*\0",
		                            DEFAULT_COLORS_FILE_EXTENSION, true);
		    if(wHandler)
		    {
		        _colFileLoader(path);
		        sprint("%s\nFile has been correctly loaded.\n\n", path);
		    }
		    else
		        printErr(14, "Failed to select Colors Settings File");
		}
		else
	#endif
    {
        if(argc)
        {
            if(!file_exists(argv[0]))
            {
                printErr(2, "Inserted Path:\n%s\nrefers to non-existent File", argv[0]);
                return;
            }
            strcpy(path, argv[0]);
        }
        else
        {
            bool assert;

            printf2(COLOR_CREDITS, "Enter the Path of the "DEFAULT_LAYOUT_FILE_EXTENSION" File you wish to load.\n");
            printf2(COLOR_CREDITS, "or insert %c to exit SubProgram.\n\n", SCANFEXIT_CHAR);
            PRINTL();

            while(scanf("%s", path) != 1 || path[0] == SCANFEXIT_CHAR || (assert = !file_exists(path)))
            {
                CLEARBUFFER();
                if(path[0] == SCANFEXIT_CHAR) return;
                if(assert)
                {
                    printErr(2, "Inserted Path:\n%s\nrefers to non-existent File", argv[0]);
                    return;
                }
            // mustcreatefile = true;
            }
        }
        _colFileLoader(path);
        sprint("%s\nFile has been correctly loaded.\n\n", path);
    }
    return;
}

STATIC
void GenAddrData(int Size, char* Label, int ofs)
{
  ofs = truncInt(ofs);
  if (Size == 1)
    printf2("\t.db\t");
  else if (Size == 2)
    printf2("\t.dw\t");
  else if (Size == 4)
    printf2("\t.dd\t");
  GenPrintLabel(Label);
  if (ofs)
    printf2(" %+d", ofs);
  puts2("");
}

void handle_tcp(const unsigned char *bytes, uint16_t segment_len) {
    struct tcphdr *tcp_hdr = (struct tcphdr *) bytes;
    tcp_hdr->th_sport = ntohs(tcp_hdr->th_sport);
    tcp_hdr->th_dport = ntohs(tcp_hdr->th_dport);
    printf2("TCP     %u -> %u, [", tcp_hdr->th_sport, tcp_hdr->th_dport);
    print_flags(tcp_hdr->th_flags);
    print2("], ");
    printf2("seq %u, ack %u, win %u\n", ntohl(tcp_hdr->seq), ntohl(tcp_hdr->ack_seq), ntohs(tcp_hdr->window));

    int data_offset = 4 * tcp_hdr->th_off;
    const unsigned char *end = bytes + data_offset;
    bytes += sizeof(struct tcphdr);

    while(bytes < end) {
        uint8_t kind = *bytes++;

        uint8_t len = 0;
        if(kind != 0 && kind != 1)
            len = *bytes++;

        printf3("        option %u: ", kind);
        switch(kind) {
            case 0: print3("end of options"); break;
            case 1: print3("no operation (NOP)"); break;
            case 2: printf3("MSS %u", (*(uint32_t*) bytes)); break;
            case 3: print3("window scale"); break;
            case 4: print3("SACK permited"); break;
            case 5: print3("SACK"); break;
            case 8: print3("timestamps"); break;
            default: print3("unknown"); break;
        }
        print3("\n");

        // advance by the size of the option read
        if(kind != 0 && kind != 1)
            bytes += len - 2;
    }

    if(tcp_hdr->th_sport == 80 || tcp_hdr->th_dport == 80) {
        handle_http((const char *) bytes);
    }
    else if(tcp_hdr->th_sport == 23 || tcp_hdr->th_dport == 23) {
        handle_telnet(bytes, segment_len - data_offset);
    }
    else {
        printf1("???     Unknown TCP application with ports %u -> %u\n", tcp_hdr->th_sport, tcp_hdr->th_dport);
    }
}

STATIC
void GenSaveRestoreRegs(int save)
{
  int rstart, rstop, rinc, r;
  int mask = GenRegsUsed;
  mask &= ~(1 << Tr32OpReg0); // not preserved
//  mask &= ~(1 << Tr32OpRegY); // TBD??? Y is preserved, right???
  mask &= ~(1 << Tr32OpRegBp); // taken care of
  mask &= ~(1 << Tr32OpRegSp); // taken care of
  mask &= ~(1 << Tr32OpRegFlags); // TBD??? flags aren't preserved, right???

  if (save)
    rstart = Tr32OpReg0, rstop = Tr32OpRegFlags, rinc = 1;
  else
    rstart = Tr32OpRegFlags, rstop = Tr32OpReg0, rinc = -1;

  for (r = rstart; r != rstop; r += rinc)
  {
    int used = (mask & (1 << r)) != 0;
    if (save || used)
    {
      int pfx = used ? ' ' : ';';
      printf2(save ? "\t%cpush\t" : "\t%cpop\t", pfx);
      GenPrintOperand(r, 0);
      GenPrintNewLine();
    }
  }
  GenRegsUsed = mask; // undo changes in GenRegsUsed by GenPrintOperand()
}

STATIC
void GenPrintInstr(int instr, int val)
{
  char* p = "";

  (void)val;

  switch (instr)
  {
  case Tr32InstrNop  : p = "nop"; break;

  case Tr32InstrMov  : p = "mov"; break;

  case Tr32InstrLB   : p = "loadb"; break;
  case Tr32InstrLW   : p = "loadw"; break;
  case Tr32InstrL    : p = "load"; break;
  case Tr32InstrSB   : p = "storeb"; break;
  case Tr32InstrSW   : p = "storew"; break;
  case Tr32InstrS    : p = "store"; break;

  case Tr32InstrSigxB: p = "sigxb"; break;
  case Tr32InstrSigxW: p = "sigxw"; break;

  case Tr32InstrAdd  : p = "add"; break;
  case Tr32InstrSub  : p = "sub"; break;
  case Tr32InstrRSub : p = "rsb"; break;
  case Tr32InstrAnd  : p = "and"; break;
  case Tr32InstrOr   : p = "or"; break;
  case Tr32InstrXor  : p = "xor"; break;
  case Tr32InstrNot  : p = "not"; break;
  case Tr32InstrLLS  : p = "lls"; break;
  case Tr32InstrLRS  : p = "lrs"; break;
  case Tr32InstrARS  : p = "ars"; break;
  case Tr32InstrMul  : p = "mul"; break;
  case Tr32InstrSDiv : p = "sdiv"; break;
  case Tr32InstrDiv  : p = "div"; break;

  case Tr32InstrRJmp : p = "rjmp"; break;
  case Tr32InstrRCall: p = "rcall"; break;
  case Tr32InstrCall : p = "call"; break;
  case Tr32InstrRet  : p = "ret"; break;
  case Tr32InstrPush : p = "push"; break;
  case Tr32InstrPop  : p = "pop"; break;

  case Tr32InstrIfSL   : p = "ifsl"; break;
  case Tr32InstrIfSGE  : p = "ifsge"; break;
  case Tr32InstrIfSG   : p = "ifsg"; break;
  case Tr32InstrIfSLE  : p = "ifsle"; break;
  case Tr32InstrIfL    : p = "ifl"; break;
  case Tr32InstrIfGE   : p = "ifge"; break;
  case Tr32InstrIfG    : p = "ifg"; break;
  case Tr32InstrIfLE   : p = "ifle"; break;
  case Tr32InstrIfEq   : p = "ifeq"; break;
  case Tr32InstrIfNEq  : p = "ifneq"; break;
  case Tr32InstrIfBits : p = "ifbits"; break;
  case Tr32InstrIfClear: p = "ifclear"; break;
  }

  printf2("\t%s\t", p);
}

void GenPreIdentAccess(int label)
{
  if (UseGp)
    return;
  printf2("\t.set\tnoat\n\tlui\t$1, %%hi(");
  GenPrintLabel(IdentTable + label);
  puts2(")");
}

STATIC
void GenWriteFrameSize(void)
{
  unsigned size = -CurFxnMinLocalOfs;
  int pfx = size ? ' ' : ';';
  printf2("\t%csub\t%%sp, %%sp, %10u\n", pfx, size); // 10 chars are enough for 32-bit unsigned ints
  GenSaveRestoreRegs(1);
}