Validação do número de registro de CNH

Conta := (Soma div 11) * 11;
DVx := Soma - Conta;
if DVx < 2 then
  Dv := 0
else
  Dv := 11 - DVx;

function ValidaCNH(sCNH: string; lExibeMsg: boolean): boolean;
const
  String1 = ´090807060504030201´;
  String2 = ´100908070605040302´;
var
  i,j,Digito: byte;
  Controle, DigitoInformado: string[2];
  StringX: string;
  Soma: smallint;
begin
  sCNH := Copy(´00000000000´+Trim(sCNH),(Length(Trim(sCNH))+11)-10,11 );

  Controle := ´  ´;
  DigitoInformado := Copy( sCNH,10,2 );
  StringX := String1;

  if sCNH <> ´00000000000´ then
  for i := 1 to 2 do
  begin
    Soma := 0;
    if i = 2 then StringX := String2;
    for j := 1 to 9 do
      Soma := Soma + ( StrToInt(sCNH[j]) * StrToIntDef( Copy( StringX,j+(j-1),2 ),0 ) );
    Digito := Soma Mod 11;
    if Digito >= 10 then
      Digito := 0;
    Controle[i] := IntToStr( Digito )[1];
  end;

  Result := Controle = DigitoInformado;

  if not Result and lExibeMsg then
    Application.MessageBox(´Número de CNH inválido!´,´Atenção´,mb_TaskModal + mb_IconWarning);
end;

    if Digito >= 10 then
      Digito := 0;

    if Digito >= 10 then
      Digito := 1;

    if Digito > 9 then
      Digito := 11 - Digito;

function VRegCnh(PVRegCnh)
{
var Soma, Digito1, Digito2, Incr_dig2; //: integer;
var CNH_Forn, Dig_Forn, Dig_Enc;// : string;

if (PVRegCnh.length != 11)
	return
	
CNH_Forn = PVRegCnh.slice(0,9);
Dig_Forn = PVRegCnh.slice(9);

Incr_Dig2 = 0;

// calcula o digito 1 (10º caractere)
Soma = 0;
Mult = 9;

for(j=1;j 9)
		{
		Digito1 = 0;
		}
	
// calcula o digito 2 (11º caractere)
Soma = 0;
Mult = 1;
for (j=1; j= 10)
			{
			Digito2 = 0;
			}	
		
//alert("PVRegCnh:"+PVRegCnh+" | CNH_Forn:"+CNH_Forn+" | Dig_Forn:"+Dig_Forn+" | Digito1:"+Digito1+" | Digito2:"+Digito2);

if (Digito1 != PVRegCnh[9] || Digito2 != PVRegCnh[10])
	{return "V";}//alert("A CNH está incorreta!\n\nOs dígitos verificadores são inválidos!");}
else
    return "F";
}

<?php  class cnh extends CValidator {

    /**
     * Validates the attribute of the object.
     * If there is any error, the error message is added to the object.
     * @param CModel the data object being validated
     * @param string the name of the attribute to be validated.
     */
    protected function validateAttribute($object, $attribute) {
        if (!$this->validaCnh($object->$attribute)) {
            $this->addError($object, $attribute, Yii::t('yii', ' não é um número válido.'));
        }
    }

    // Função que valida o número da CNH
    private function validaCnh($pvRegCnh) { // Verifiva se o número digitado contém todos os digitos
        $result = false;

        if (strlen(trim($pvRegCnh)) < 11) { // Caso tenha menos de 11 dígitos
            return false;
        }


        $cnh_forn = substr($pvRegCnh, 0, 9); // Deixa dois dígitos de fora
        $dig_forn = substr($pvRegCnh, 9, 2);
        $incr_dig2 = 0;

        $soma = 0;

        $mult = 9;

        for ($j = 0; $j < 9; $j++) {
            $soma = $soma + (intval(substr($cnh_forn, $j, 1)) * $mult);
            $mult = $mult - 1;
        }

        $digito1 = $soma % 11;

        if ($digito1 == 10) {
            $incr_dig2 = -2;
        }
        if ($digito1 > 9) {
            $digito1 = 0;
        }

        $soma = 0;

        $mult = 1;

        for ($j = 0; $j < 9; $j++) {
            $soma = $soma + (intval(substr($cnh_forn, $j, 1)) * $mult);
            $mult = $mult + 1;
        }

        if ((($soma % 11) * $incr_dig2) < 0) {
            $digito2 = 11 + ($soma % 11) + $incr_dig2;
        }

        if ((($soma % 11) + $incr_dig2) >= 0) {
            $digito2 = ($soma % 11) + $incr_dig2;
        }

        if ($digito2 > 9) {
            $digito2 = 0;
        }

        $dig_enc = strval($digito1) + strval($digito2);

        if ($dig_forn == $dig_enc) {
            return true;
        } else {
            return false;
        }
    }

}

if (strlen(trim($pvRegCnh)) < 11) { // Caso tenha menos de 11 dígitos
            return false;
}

if (strlen(trim($pvRegCnh)) < 11) { // Caso tenha menos de 11 dígitos
            return $this->validaCnhAntiga($pvRegCnh);
}

    private function validaCnhAntiga($pvPguCnh) {

        if (strlen(trim($pvPguCnh)) <> 9) {
            return false;
        }

        $pgu_forn = substr($pvPguCnh, 0, 8);
        $dig_forn = substr($pvPguCnh, 8, 1);

        $soma = 0;
        $mult = 2;
        
        for ($j = 0; $j < 9; $j++) {
            $soma = $soma + (intval(substr($pgu_forn, $j, 1)) * $mult);
        }
        $digito = $soma % 11;

        if ($digito > 9) {
            $digito = 0;
        }
        
        $dig_enc = strval($digito);
        
        if ($dig_forn == $dig_enc) {
            return true;
        } else {
            return false;
        }
        
    }

$dig_enc = strval($digito1) + strval($digito2);

$dig_enc = strval($digito1) . strval($digito2);

    public static function validaCNH($cnh){


        // Subfunção para calcular os dígitos
        function CalculaDigito($identificacao, $digito){

            // Inicializa a variável
            $soma = 0;

            // Atribui o fator de acordo com o dígito a ser calculado
            $digito == 1 ? $fator = 9 : $fator = 1;

            // Percorre os 9 primeiros dígitos da CNH
            for($i = 0; $i < 9; $i++){

                // Multiplica o dígito pelo fator
                $soma += (int)$identificacao[$i] * $fator;

                // Incrementa ou decrementa o fator de acordo com o dígito a ser calculado
                $digito == 1 ? $fator-- : $fator++;
            }

            // Retorna o cálculo do dígito
            return $soma % 11;
        }

        // Verifica se a CNH informada é no modelo novo (11 dígitos)
        if(strlen($cnh) == 11){

            // Recupera os 9 primeiros dígitos da CNH informada
            $identificacao = substr($cnh, 0, 9);

            //Chama a função que faz o cálculo do primeiro dígito
            $digito1 = CalculaDigito($identificacao, 1);

            //Chama a função que faz o cálculo do segundo dígito
            $digito2 = CalculaDigito($identificacao, 2);

            // Se o primeiro dígito é igual a 10, decrementa 2 do segundo
            if($digito1 == 10) $digito2 -= 2;

            // Se for menor que 0, incrementa 11 ao segundo dígito
            if($digito2 < 0) $digito2 += 11;

            // Zera os dígitos caso estes sejam maior que 9
            if($digito1 > 9) $digito1 = 0;
            if($digito2 > 9) $digito2 = 0;

            // Armazena os dígitos do cálculo para efetuar a comparação
            (string)$digitosCalculo = $digito1 . $digito2;

            // Recupera os 2 últimos dígitos verificadores da CNH informada
            $digitos = substr($cnh, 9, 2);

            // Verifica se os dígitos verificadores são iguais ao do cálculo
            if($digitos == $digitosCalculo){

                // Indica que a CNH é válida
                return true;
            }
        }

        // Verifica se a CNH informada é no modelo antigo (9 dígitos)
        if(strlen($cnh) == 9){

            // Recupera os 8 primeiros dígitos da CNH informada
            $identificacao = substr($cnh, 0, 8);

            // Inicializa a variável
            $soma = 0;

            // Inicializa o fator
            $fator = 2;

            // Faz o cálculo do dígito
            for($i = 0; $i < 8; $i++){

                // Multiplica o dígito pelo fator
                $soma += (int)$identificacao[$i] * $fator;

                // Incrementa o fator
                $fator++;
            }

            // Recupera o dígito
            $digitoCalc = $soma % 11;

            // Zera o dígito se for maior que 9
            if($digitoCalc > 9) $digito = 0;

            // Recupera o dígito da CNH informada
            $digitoCnh = substr($cnh, 8, 1);

            // Verifica se o dígito verificador é iguail ao do cálculo
            if($digitoCnh == $digitoCalc){

                // Indica que a CNH é válida
                return true;
            }
        }

        //CNH inválida
        return false;
    }