C++ COMMENT函数代码示例

/*------------------------------------------------------------------------------
  H264FillerSei()  Filler payload SEI message. Requested filler payload size
  could be huge. Use of temporary stream buffer is not needed, because size is
  know.
------------------------------------------------------------------------------*/
void H264FillerSei(stream_s * sp, sei_s * sei, i32 cnt)
{
    i32 i = cnt;

    ASSERT(sp != NULL && sei != NULL);

    H264NalUnitHdr(sp, 0, SEI, sei->byteStream);

    H264NalBits(sp, SEI_FILLER_PAYLOAD, 8);
    COMMENT("last_payload_type_byte");

    while(cnt >= 255)
    {
        H264NalBits(sp, 0xFF, 0x8);
        COMMENT("ff_byte");
        cnt -= 255;
    }
    H264NalBits(sp, cnt, 8);
    COMMENT("last_payload_size_byte");

    for(; i > 0; i--)
    {
        H264NalBits(sp, 0xFF, 8);
        COMMENT("filler ff_byte");
    }
    H264RbspTrailingBits(sp);
}

void output_mm_defines(void)
{
	COMMENT("Size of struct page");
	DEFINE(STRUCT_PAGE_SIZE, sizeof(struct page));
	BLANK();
	COMMENT("Linux mm_struct offsets.");
	OFFSET(MM_USERS, mm_struct, mm_users);
	OFFSET(MM_PGD, mm_struct, pgd);
	OFFSET(MM_CONTEXT, mm_struct, context);
	BLANK();
	DEFINE(_PAGE_SIZE, PAGE_SIZE);
	DEFINE(_PAGE_SHIFT, PAGE_SHIFT);
	BLANK();
	DEFINE(_PGD_T_SIZE, sizeof(pgd_t));
	DEFINE(_PTE_T_SIZE, sizeof(pte_t));
	BLANK();
	DEFINE(_PGD_ORDER, PGD_ORDER);
	DEFINE(_PTE_ORDER, PTE_ORDER);
	BLANK();
	DEFINE(_PGDIR_SHIFT, PGDIR_SHIFT);
	BLANK();
	DEFINE(_PTRS_PER_PGD, PTRS_PER_PGD);
	DEFINE(_PTRS_PER_PTE, PTRS_PER_PTE);
	BLANK();
}

/*------------------------------------------------------------------------------

	VideoSignalType

------------------------------------------------------------------------------*/
void VideoSignalType(stream_s * stream, videoSignalType_s * vst)
{
    if(vst->videoSignalType == ENCHW_YES)
    {
        EncPutBits(stream, 1, 1);
        COMMENT("Video Signal Type");
        EncPutBits(stream, vst->videoFormat, 3);
        COMMENT("Video Format");
        EncPutBits(stream, vst->videoRange, 1);
        COMMENT("Video Range");
        if(vst->colourDescription == ENCHW_YES)
        {
            EncPutBits(stream, 1, 1);
            COMMENT("Colour Description");
            EncPutBits(stream, vst->colourPrimaries, 8);
            COMMENT("Colour Primaries");
            EncPutBits(stream, vst->transferCharacteristics, 8);
            COMMENT("Transfer Characteristics");
            EncPutBits(stream, vst->matrixCoefficients, 8);
            COMMENT("Matrix Coefficients");
        }
        else
        {
            EncPutBits(stream, 0, 1);
            COMMENT("Colour Description");
        }
    }
    else
    {
        EncPutBits(stream, 0, 1);
        COMMENT("Video Signal Type");
    }

    return;
}

/* This function is not intended to be executed. It is needed to provide
 * the numeric values of the needed offsets. */
void 
kedr_offsets_holder(void)
{
	/* kedr_local_storage */
	COMMENT("Offsets of the fields in struct kedr_local_storage");
	
	/* Register spill slots */
	DEFINE(KEDR_LSTORAGE_ax, KEDR_OFFSET_LS_REG(INAT_REG_CODE_AX));
	DEFINE(KEDR_LSTORAGE_cx, KEDR_OFFSET_LS_REG(INAT_REG_CODE_CX));
	DEFINE(KEDR_LSTORAGE_dx, KEDR_OFFSET_LS_REG(INAT_REG_CODE_DX));
	DEFINE(KEDR_LSTORAGE_bx, KEDR_OFFSET_LS_REG(INAT_REG_CODE_BX));
	DEFINE(KEDR_LSTORAGE_sp, KEDR_OFFSET_LS_REG(INAT_REG_CODE_SP));
	DEFINE(KEDR_LSTORAGE_bp, KEDR_OFFSET_LS_REG(INAT_REG_CODE_BP));
	DEFINE(KEDR_LSTORAGE_si, KEDR_OFFSET_LS_REG(INAT_REG_CODE_SI));
	DEFINE(KEDR_LSTORAGE_di, KEDR_OFFSET_LS_REG(INAT_REG_CODE_DI));

#ifdef CONFIG_X86_64
	DEFINE(KEDR_LSTORAGE_r8, KEDR_OFFSET_LS_REG(INAT_REG_CODE_8));
	DEFINE(KEDR_LSTORAGE_r9, KEDR_OFFSET_LS_REG(INAT_REG_CODE_9));
	DEFINE(KEDR_LSTORAGE_r10, KEDR_OFFSET_LS_REG(INAT_REG_CODE_10));
	DEFINE(KEDR_LSTORAGE_r11, KEDR_OFFSET_LS_REG(INAT_REG_CODE_11));
	DEFINE(KEDR_LSTORAGE_r12, KEDR_OFFSET_LS_REG(INAT_REG_CODE_12));
	DEFINE(KEDR_LSTORAGE_r13, KEDR_OFFSET_LS_REG(INAT_REG_CODE_13));
	DEFINE(KEDR_LSTORAGE_r14, KEDR_OFFSET_LS_REG(INAT_REG_CODE_14));
	DEFINE(KEDR_LSTORAGE_r15, KEDR_OFFSET_LS_REG(INAT_REG_CODE_15));
#endif
	/* The array of local values */
	OFFSET(KEDR_LSTORAGE_values, kedr_local_storage, values);
	
	/* Other fields */
	OFFSET(KEDR_LSTORAGE_tid, kedr_local_storage, tid);
	OFFSET(KEDR_LSTORAGE_fi, kedr_local_storage, fi);
	OFFSET(KEDR_LSTORAGE_write_mask, kedr_local_storage, write_mask);
	OFFSET(KEDR_LSTORAGE_info, kedr_local_storage, info);
	OFFSET(KEDR_LSTORAGE_dest_addr, kedr_local_storage, dest_addr);
	OFFSET(KEDR_LSTORAGE_temp, kedr_local_storage, temp);
	OFFSET(KEDR_LSTORAGE_temp1, kedr_local_storage, temp1);
	OFFSET(KEDR_LSTORAGE_temp_bx, kedr_local_storage, temp_bx);
	OFFSET(KEDR_LSTORAGE_temp_bp, kedr_local_storage, temp_bp);
	OFFSET(KEDR_LSTORAGE_ret_val, kedr_local_storage, ret_val);
	OFFSET(KEDR_LSTORAGE_ret_val_high, kedr_local_storage, ret_val_high);
	OFFSET(KEDR_LSTORAGE_ret_addr, kedr_local_storage, ret_addr);
	OFFSET(KEDR_LSTORAGE_temp_aux, kedr_local_storage, temp_aux);
	BLANK();
	
	/* kedr_call_info */
	COMMENT("Offsets of the fields in struct kedr_call_info");
	OFFSET(KEDR_CALL_INFO_pc, kedr_call_info, pc);
	OFFSET(KEDR_CALL_INFO_target, kedr_call_info, target);
	OFFSET(KEDR_CALL_INFO_repl, kedr_call_info, repl);
	OFFSET(KEDR_CALL_INFO_pre_handler, kedr_call_info, pre_handler);
	OFFSET(KEDR_CALL_INFO_post_handler, kedr_call_info, post_handler);
}

/*------------------------------------------------------------------------------

    Function name: EncJpegRestartInterval

    Functional description: Sets DRI header data

    Inputs:

    Outputs:

------------------------------------------------------------------------------*/
void EncJpegRestartInterval(stream_s * stream, jpegData_s * data)
{
    if(data->restart.Ri != 0)
    {
        EncJpegHeaderPutBits(stream, DRI, 16);
        COMMENT("DRI");

        data->restart.Lr = 4;

        EncJpegHeaderPutBits(stream, data->restart.Lr, 16);
        COMMENT("Lr");
        EncJpegHeaderPutBits(stream, data->restart.Ri, 16);
        COMMENT("Rq");
    }
}

void output_thread_defines(void)
{
	COMMENT("MIPS specific thread_struct offsets.");
	OFFSET(THREAD_REG16, task_struct, thread.reg16);
	OFFSET(THREAD_REG17, task_struct, thread.reg17);
	OFFSET(THREAD_REG18, task_struct, thread.reg18);
	OFFSET(THREAD_REG19, task_struct, thread.reg19);
	OFFSET(THREAD_REG20, task_struct, thread.reg20);
	OFFSET(THREAD_REG21, task_struct, thread.reg21);
	OFFSET(THREAD_REG22, task_struct, thread.reg22);
	OFFSET(THREAD_REG23, task_struct, thread.reg23);
	OFFSET(THREAD_REG29, task_struct, thread.reg29);
	OFFSET(THREAD_REG30, task_struct, thread.reg30);
	OFFSET(THREAD_REG31, task_struct, thread.reg31);
	OFFSET(THREAD_STATUS, task_struct,
	       thread.cp0_status);
#ifdef CONFIG_CPU_SUPPORTS_VECTOR_COPROCESSOR
	OFFSET(THREAD_VPU, task_struct, thread.vpu);
#endif
	OFFSET(THREAD_FPU, task_struct, thread.fpu);

	OFFSET(THREAD_BVADDR, task_struct, \
	       thread.cp0_badvaddr);
	OFFSET(THREAD_BUADDR, task_struct, \
	       thread.cp0_baduaddr);
	OFFSET(THREAD_ECODE, task_struct, \
	       thread.error_code);
	OFFSET(THREAD_TRAMP, task_struct, \
	       thread.irix_trampoline);
	OFFSET(THREAD_OLDCTX, task_struct, \
	       thread.irix_oldctx);
	BLANK();
}

int
skipWhiteSpace(
    UCHAR stream
    )
{
    int c;

    do {
        c = GET(stream);
        if (WHITESPACE(c) || c == ESCH) {
            if (c == ESCH) {
                c = GET(stream);
                if (!WHITESPACE(c)) {   // push char back out, return esch
                    UngetTxtChr(c, file);
                    c = ESCH;
                    break;
                }
            }
            colZero = FALSE;            // we've moved past col 0
        }

        if (c == '\\')
            c = skipBackSlash(c, stream);
    } while(WHITESPACE(c));

    if (COMMENT(c,colZero,init)) {
        skipComments(stream);           // current char is always
        c = '\n';                       // \n after comments
        colZero = TRUE;                 // always in col 0 after a comment
    }
    return(c);                          // true if we're in col 0
}

void output_thread_defines(void)
{
	COMMENT("SCORE specific thread_struct offsets.");
	OFFSET(THREAD_REG0, task_struct, thread.reg0);
	OFFSET(THREAD_REG2, task_struct, thread.reg2);
	OFFSET(THREAD_REG3, task_struct, thread.reg3);
	OFFSET(THREAD_REG12, task_struct, thread.reg12);
	OFFSET(THREAD_REG13, task_struct, thread.reg13);
	OFFSET(THREAD_REG14, task_struct, thread.reg14);
	OFFSET(THREAD_REG15, task_struct, thread.reg15);
	OFFSET(THREAD_REG16, task_struct, thread.reg16);
	OFFSET(THREAD_REG17, task_struct, thread.reg17);
	OFFSET(THREAD_REG18, task_struct, thread.reg18);
	OFFSET(THREAD_REG19, task_struct, thread.reg19);
	OFFSET(THREAD_REG20, task_struct, thread.reg20);
	OFFSET(THREAD_REG21, task_struct, thread.reg21);
	OFFSET(THREAD_REG29, task_struct, thread.reg29);

	OFFSET(THREAD_PSR, task_struct, thread.cp0_psr);
	OFFSET(THREAD_EMA, task_struct, thread.cp0_ema);
	OFFSET(THREAD_BADUADDR, task_struct, thread.cp0_baduaddr);
	OFFSET(THREAD_ECODE, task_struct, thread.error_code);
	OFFSET(THREAD_TRAPNO, task_struct, thread.trap_no);
	BLANK();
}

std::string
GCodeWriter::_retract(double length, double restart_extra, const std::string &comment)
{
    std::ostringstream gcode;
    
    /*  If firmware retraction is enabled, we use a fake value of 1
        since we ignore the actual configured retract_length which 
        might be 0, in which case the retraction logic gets skipped. */
    if (this->config.use_firmware_retraction) length = 1;
    
    // If we use volumetric E values we turn lengths into volumes */
    if (this->config.use_volumetric_e) {
        double d = this->_extruder->filament_diameter();
        double area = d * d * PI/4;
        length = length * area;
        restart_extra = restart_extra * area;
    }
    
    double dE = this->_extruder->retract(length, restart_extra);
    if (dE != 0) {
        if (this->config.use_firmware_retraction) {
            gcode << "G10 ; retract\n";
        } else {
            gcode << "G1 " << this->_extrusion_axis << E_NUM(this->_extruder->E)
                           << " F" << this->_extruder->retract_speed_mm_min;
            COMMENT(comment);
            gcode << "\n";
        }
    }
    
    if (FLAVOR_IS(gcfMakerWare))
        gcode << "M103 ; extruder off\n";
    
    return gcode.str();
}

int main ()
{
    INIT_INFO ("SolveSquareEquation");

    COMMENT ("Enter a, b, c for ax^2 + bx + c = 0:");
    double a = 0, b = 0, c = 0;

    if (!INPUT (a) || !INPUT (b) || !INPUT(c))
        return 1;

    double x1 = 0, x2 = 0;
    int nRoots = SolveSquareEquation(a, b, c, &x1, &x2);

    switch (nRoots)
    {
    case 0:
        printf ("#No roots\n");
        break;
    case 1:
        printf ("#One root: x1 = %lg\n", x1);
        break;
    case 2:
        printf ("#Two roots: x1 = %lg, x2 = %lg\n", x1, x2);
        break;
    case INFINITE_ROOTS:
        printf ("#Infinite number of roots\n");
        break;
    }

    return 0;
}

void output_octeon_cop2_state_defines(void)
{
	COMMENT("Octeon specific octeon_cop2_state offsets.");
	OFFSET(OCTEON_CP2_CRC_IV,	octeon_cop2_state, cop2_crc_iv);
	OFFSET(OCTEON_CP2_CRC_LENGTH,	octeon_cop2_state, cop2_crc_length);
	OFFSET(OCTEON_CP2_CRC_POLY,	octeon_cop2_state, cop2_crc_poly);
	OFFSET(OCTEON_CP2_LLM_DAT,	octeon_cop2_state, cop2_llm_dat);
	OFFSET(OCTEON_CP2_3DES_IV,	octeon_cop2_state, cop2_3des_iv);
	OFFSET(OCTEON_CP2_3DES_KEY,	octeon_cop2_state, cop2_3des_key);
	OFFSET(OCTEON_CP2_3DES_RESULT,	octeon_cop2_state, cop2_3des_result);
	OFFSET(OCTEON_CP2_AES_INP0,	octeon_cop2_state, cop2_aes_inp0);
	OFFSET(OCTEON_CP2_AES_IV,	octeon_cop2_state, cop2_aes_iv);
	OFFSET(OCTEON_CP2_AES_KEY,	octeon_cop2_state, cop2_aes_key);
	OFFSET(OCTEON_CP2_AES_KEYLEN,	octeon_cop2_state, cop2_aes_keylen);
	OFFSET(OCTEON_CP2_AES_RESULT,	octeon_cop2_state, cop2_aes_result);
	OFFSET(OCTEON_CP2_GFM_MULT,	octeon_cop2_state, cop2_gfm_mult);
	OFFSET(OCTEON_CP2_GFM_POLY,	octeon_cop2_state, cop2_gfm_poly);
	OFFSET(OCTEON_CP2_GFM_RESULT,	octeon_cop2_state, cop2_gfm_result);
	OFFSET(OCTEON_CP2_HSH_DATW,	octeon_cop2_state, cop2_hsh_datw);
	OFFSET(OCTEON_CP2_HSH_IVW,	octeon_cop2_state, cop2_hsh_ivw);
	OFFSET(OCTEON_CP2_SHA3,		octeon_cop2_state, cop2_sha3);
	OFFSET(THREAD_CP2,	task_struct, thread.cp2);
	OFFSET(THREAD_CVMSEG,	task_struct, thread.cvmseg.cvmseg);
	BLANK();
}

std::string
GCodeWriter::travel_to_xyz(const Pointf3 &point, const std::string &comment)
{
    /*  If target Z is lower than current Z but higher than nominal Z we
        don't perform the Z move but we only move in the XY plane and
        adjust the nominal Z by reducing the lift amount that will be 
        used for unlift. */
    if (!this->will_move_z(point.z)) {
        double nominal_z = this->_pos.z - this->_lifted;
        this->_lifted = this->_lifted - (point.z - nominal_z);
        return this->travel_to_xy(point);
    }
    
    /*  In all the other cases, we perform an actual XYZ move and cancel
        the lift. */
    this->_lifted = 0;
    this->_pos = point;
    
    std::ostringstream gcode;
    gcode << "G1 X" << XYZF_NUM(point.x)
          <<   " Y" << XYZF_NUM(point.y)
          <<   " Z" << XYZF_NUM(point.z)
          <<   " F" << XYZF_NUM(this->config.travel_speed.value * 60.0);
    COMMENT(comment);
    gcode << "\n";
    return gcode.str();
}

main(int argc,char *argv[])
{
  if (argc != 2) {
    fprintf(stderr,"usage: %s name-for-package\n", argv[0]);
    exit(1);
  }
  NEWLINE();
  PUTS("package "); PUTS(argv[1]); PUTS(" : Cc_Info =\n");
  PUTS("\tstruct\n");
  PUTS("\t\t");COMMENT("all sizes in bytes");
  NEWLINE();
  PUTVAL("intSzB", sizeof(int));
  PUTVAL("shortSzB", sizeof(short));
  PUTVAL("longSzB", sizeof(long));
  NEWLINE();
  PUTVAL("charSzB", sizeof(char));
  NEWLINE();
  PUTVAL("floatSzB", sizeof(float));
  PUTVAL("doubleSzB", sizeof(double));
  NEWLINE();
  PUTVAL("ptrSzB", sizeof(int *));
  NEWLINE();
  PUTVAL("unionAlign", sizeof(int *));
  PUTVAL("structAlign", sizeof(int *));
  NEWLINE();
  PUTS("\tend "); PUTS("/* package "); PUTS(argv[1]); PUTS(" */\n");
  exit(0);
}

void output_thread_defines(void)
{
	COMMENT("MIPS specific thread_struct offsets.");
	OFFSET(THREAD_REG16, task_struct, thread.reg16);
	OFFSET(THREAD_REG17, task_struct, thread.reg17);
	OFFSET(THREAD_REG18, task_struct, thread.reg18);
	OFFSET(THREAD_REG19, task_struct, thread.reg19);
	OFFSET(THREAD_REG20, task_struct, thread.reg20);
	OFFSET(THREAD_REG21, task_struct, thread.reg21);
	OFFSET(THREAD_REG22, task_struct, thread.reg22);
	OFFSET(THREAD_REG23, task_struct, thread.reg23);
	OFFSET(THREAD_REG29, task_struct, thread.reg29);
	OFFSET(THREAD_REG30, task_struct, thread.reg30);
	OFFSET(THREAD_REG31, task_struct, thread.reg31);
	OFFSET(THREAD_STATUS, task_struct,
	       thread.cp0_status);
	OFFSET(THREAD_FPU, task_struct, thread.fpu);

	OFFSET(THREAD_BVADDR, task_struct, \
	       thread.cp0_badvaddr);
	OFFSET(THREAD_BUADDR, task_struct, \
	       thread.cp0_baduaddr);
	OFFSET(THREAD_ECODE, task_struct, \
	       thread.error_code);
	BLANK();
}

/*------------------------------------------------------------------------------
  H264BufferingSei()  Buffering period SEI message.
------------------------------------------------------------------------------*/
void H264BufferingSei(stream_s * sp, sei_s * sei)
{
    u8 *pPayloadSizePos;
    u32 startByteCnt;

    ASSERT(sei != NULL);

    if(sei->hrd == ENCHW_NO)
    {
        return;
    }

    H264NalBits(sp, SEI_BUFFERING_PERIOD, 8);
    COMMENT("last_payload_type_byte");

    pPayloadSizePos = sp->stream;

    H264NalBits(sp, 0xFF, 8);   /* this will be updated after we know exact payload size */
    COMMENT("last_payload_size_byte");

    startByteCnt = sp->byteCnt;
    sp->emulCnt = 0;    /* count emul_3_byte for this payload */

    H264ExpGolombUnsigned(sp, sei->seqId);
    COMMENT("seq_parameter_set_id");

    H264NalBits(sp, sei->icrd, sei->icrdLen);
    COMMENT("initial_cpb_removal_delay");

    H264NalBits(sp, sei->icrdo, sei->icrdoLen);
    COMMENT("initial_cpb_removal_delay_offset");

    if(sp->bufferedBits)
    {
        H264RbspTrailingBits(sp);
    }

    {
        u32 payload_size;

        payload_size = sp->byteCnt - startByteCnt - sp->emulCnt;
        *pPayloadSizePos = payload_size;
    }

    /* reset cpb_removal_delay */
    sei->crd = 0;
}