SHARE
TWEET

Untitled

a guest Jul 30th, 2018 135 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. *--------------------------------------------------------------------------
  2. * FUNCTION Num2Let(tnNumero)
  3. *--------------------------------------------------------------------------
  4. * Devuelve un número en letras con centavos
  5. * USO: ? Num2Let(15.11) -> QUINCE CON ONCE CENTAVOS
  6. * RETORNA: Caracter
  7. * AUTOR: LMG
  8. *--------------------------------------------------------------------------
  9. Function Num2Let(tnNumero)
  10. Local lnEntero, lnFraccion
  11. *-- Elegir si se REDONDEA o TRUNCA
  12. * tnNumero = ROUND(tnNumero, 2)  && Redondeo a 2 decimales
  13. tnNumero = Int(tnNumero*100)/100 && Trunco a dos decimales
  14. lnEntero = Int(tnNumero)
  15. lnFraccion = Int((tnNumero - lnEntero) * 100)
  16. Return N2L(lnEntero, 0) + 'CON ' + ;
  17.     N2L(lnFraccion, 1) + 'CENTAVOS.'
  18. Endfunc
  19.  
  20. *--------------------------------------------------------------------------
  21. * FUNCTION N2L(tnNro, tnFlag)
  22. *--------------------------------------------------------------------------
  23. * Devuelve un número entero en letras
  24. * Usada por Let2Num (deben estar ambas)
  25. * USO: ? N2L(32) -> TREINTA Y DOS
  26. * RETORNA: Caracter
  27. * AUTOR: LMG
  28. *--------------------------------------------------------------------------
  29. Function N2L(tnNro, tnFlag)
  30. If Empty(tnFlag)
  31.     tnFlag = 0
  32. Endif
  33. Local lnEntero, lcRetorno, lnTerna, lcMiles, ;
  34.     lcCadena, lnUnidades, lnDecenas, lnCentenas
  35. lnEntero = Int(tnNro)
  36. lcRetorno = ''
  37. lnTerna = 1
  38. Do While lnEntero > 0
  39.     lcCadena = ''
  40.     lnUnidades = Mod(lnEntero, 10)
  41.     lnEntero = Int(lnEntero / 10)
  42.     lnDecenas = Mod(lnEntero, 10)
  43.     lnEntero = Int(lnEntero / 10)
  44.     lnCentenas = Mod(lnEntero, 10)
  45.     lnEntero = Int(lnEntero / 10)
  46.  
  47. *--- Analizo la terna
  48.     Do Case
  49.     Case lnTerna = 1
  50.         lcMiles = ''
  51.     Case lnTerna = 2 And (lnUnidades + lnDecenas + lnCentenas # 0)
  52.         lcMiles = 'MIL '
  53.     Case lnTerna = 3 And (lnUnidades + lnDecenas + lnCentenas # 0)
  54.         lcMiles = Iif(lnUnidades = 1 And lnDecenas = 0 And ;
  55.             lnCentenas = 0, 'MILLON ', 'MILLONES ')
  56.     Case lnTerna = 4 And (lnUnidades + lnDecenas + lnCentenas # 0)
  57.         lcMiles = 'MIL MILLONES '
  58.     Case lnTerna = 5 And (lnUnidades + lnDecenas + lnCentenas # 0)
  59.         lcMiles = Iif(lnUnidades = 1 And lnDecenas = 0 And ;
  60.             lnCentenas = 0, 'BILLON ', 'BILLONES ')
  61.     Case lnTerna > 5
  62.         lcRetorno = ' ERROR: NUMERO DEMASIADO GRANDE '
  63.         Exit
  64.     Endcase
  65.  
  66. *--- Analizo las unidades
  67.     Do Case
  68.     Case lnUnidades = 1
  69.         lcCadena = Iif(lnTerna = 1 And tnFlag = 0, 'UNO ', 'UN ')
  70.     Case lnUnidades = 2
  71.         lcCadena = 'DOS '
  72.     Case lnUnidades = 3
  73.         lcCadena = 'TRES '
  74.     Case lnUnidades = 4
  75.         lcCadena = 'CUATRO '
  76.     Case lnUnidades = 5
  77.         lcCadena = 'CINCO '
  78.     Case lnUnidades = 6
  79.         lcCadena = 'SEIS '
  80.     Case lnUnidades = 7
  81.         lcCadena = 'SIETE '
  82.     Case lnUnidades = 8
  83.         lcCadena = 'OCHO '
  84.     Case lnUnidades = 9
  85.         lcCadena = 'NUEVE '
  86.     Endcase
  87.  
  88. *--- Analizo las decenas
  89.     Do Case
  90.     Case lnDecenas = 1
  91.         Do Case
  92.         Case lnUnidades = 0
  93.             lcCadena = 'DIEZ '
  94.         Case lnUnidades = 1
  95.             lcCadena = 'ONCE '
  96.         Case lnUnidades = 2
  97.             lcCadena = 'DOCE '
  98.         Case lnUnidades = 3
  99.             lcCadena = 'TRECE '
  100.         Case lnUnidades = 4
  101.             lcCadena = 'CATORCE '
  102.         Case lnUnidades = 5
  103.             lcCadena = 'QUINCE '
  104.         Other
  105.             lcCadena = 'DIECI' + lcCadena
  106.         Endcase
  107.     Case lnDecenas = 2
  108.         lcCadena = Iif(lnUnidades = 0, 'VEINTE ', 'VEINTI') + lcCadena
  109.     Case lnDecenas = 3
  110.         lcCadena = 'TREINTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  111.     Case lnDecenas = 4
  112.         lcCadena = 'CUARENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  113.     Case lnDecenas = 5
  114.         lcCadena = 'CINCUENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  115.     Case lnDecenas = 6
  116.         lcCadena = 'SESENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  117.     Case lnDecenas = 7
  118.         lcCadena = 'SETENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  119.     Case lnDecenas = 8
  120.         lcCadena = 'OCHENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  121.     Case lnDecenas = 9
  122.         lcCadena = 'NOVENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  123.     Endcase
  124.  
  125. *--- Analizo las centenas
  126.     Do Case
  127.     Case lnCentenas = 1
  128.         lcCadena = Iif(lnUnidades = 0 And lnDecenas = 0, ;
  129.             'CIEN ', 'CIENTO ') + lcCadena
  130.     Case lnCentenas = 2
  131.         lcCadena = 'DOSCIENTOS ' + lcCadena
  132.     Case lnCentenas = 3
  133.         lcCadena = 'TRESCIENTOS ' + lcCadena
  134.     Case lnCentenas = 4
  135.         lcCadena = 'CUATROCIENTOS ' + lcCadena
  136.     Case lnCentenas = 5
  137.         lcCadena = 'QUINIENTOS ' + lcCadena
  138.     Case lnCentenas = 6
  139.         lcCadena = 'SEISCIENTOS ' + lcCadena
  140.     Case lnCentenas = 7
  141.         lcCadena = 'SETECIENTOS ' + lcCadena
  142.     Case lnCentenas = 8
  143.         lcCadena = 'OCHOCIENTOS ' + lcCadena
  144.     Case lnCentenas = 9
  145.         lcCadena = 'NOVECIENTOS ' + lcCadena
  146.     Endcase
  147.  
  148. *--- Armo el retorno terna a terna
  149.     lcRetorno = lcCadena + lcMiles + lcRetorno
  150.     lnTerna = lnTerna + 1
  151. Enddo
  152. If lnTerna = 1
  153.     lcRetorno = 'CERO '
  154. Endif
  155. Return lcRetorno
  156. Endfu
  157. * FUNCTION Num2Let(tnNumero)
  158. *--------------------------------------------------------------------------
  159. * Devuelve un número en letras con centavos
  160. * USO: ? Num2Let(15.11) -> QUINCE CON ONCE CENTAVOS
  161. * RETORNA: Caracter
  162. * AUTOR: LMG
  163. *--------------------------------------------------------------------------
  164. Function Num2Let(tnNumero)
  165. Local lnEntero, lnFraccion
  166. *-- Elegir si se REDONDEA o TRUNCA
  167. * tnNumero = ROUND(tnNumero, 2)  && Redondeo a 2 decimales
  168. tnNumero = Int(tnNumero*100)/100 && Trunco a dos decimales
  169. lnEntero = Int(tnNumero)
  170. lnFraccion = Int((tnNumero - lnEntero) * 100)
  171. Return N2L(lnEntero, 0) + 'CON ' + ;
  172.     N2L(lnFraccion, 1) + 'CENTAVOS.'
  173. Endfunc
  174.  
  175. *--------------------------------------------------------------------------
  176. * FUNCTION N2L(tnNro, tnFlag)
  177. *--------------------------------------------------------------------------
  178. * Devuelve un número entero en letras
  179. * Usada por Let2Num (deben estar ambas)
  180. * USO: ? N2L(32) -> TREINTA Y DOS
  181. * RETORNA: Caracter
  182. * AUTOR: LMG
  183. *--------------------------------------------------------------------------
  184. Function N2L(tnNro, tnFlag)
  185. If Empty(tnFlag)
  186.     tnFlag = 0
  187. Endif
  188. Local lnEntero, lcRetorno, lnTerna, lcMiles, ;
  189.     lcCadena, lnUnidades, lnDecenas, lnCentenas
  190. lnEntero = Int(tnNro)
  191. lcRetorno = ''
  192. lnTerna = 1
  193. Do While lnEntero > 0
  194.     lcCadena = ''
  195.     lnUnidades = Mod(lnEntero, 10)
  196.     lnEntero = Int(lnEntero / 10)
  197.     lnDecenas = Mod(lnEntero, 10)
  198.     lnEntero = Int(lnEntero / 10)
  199.     lnCentenas = Mod(lnEntero, 10)
  200.     lnEntero = Int(lnEntero / 10)
  201.  
  202. *--- Analizo la terna
  203.     Do Case
  204.     Case lnTerna = 1
  205.         lcMiles = ''
  206.     Case lnTerna = 2 And (lnUnidades + lnDecenas + lnCentenas # 0)
  207.         lcMiles = 'MIL '
  208.     Case lnTerna = 3 And (lnUnidades + lnDecenas + lnCentenas # 0)
  209.         lcMiles = Iif(lnUnidades = 1 And lnDecenas = 0 And ;
  210.             lnCentenas = 0, 'MILLON ', 'MILLONES ')
  211.     Case lnTerna = 4 And (lnUnidades + lnDecenas + lnCentenas # 0)
  212.         lcMiles = 'MIL MILLONES '
  213.     Case lnTerna = 5 And (lnUnidades + lnDecenas + lnCentenas # 0)
  214.         lcMiles = Iif(lnUnidades = 1 And lnDecenas = 0 And ;
  215.             lnCentenas = 0, 'BILLON ', 'BILLONES ')
  216.     Case lnTerna > 5
  217.         lcRetorno = ' ERROR: NUMERO DEMASIADO GRANDE '
  218.         Exit
  219.     Endcase
  220.  
  221. *--- Analizo las unidades
  222.     Do Case
  223.     Case lnUnidades = 1
  224.         lcCadena = Iif(lnTerna = 1 And tnFlag = 0, 'UNO ', 'UN ')
  225.     Case lnUnidades = 2
  226.         lcCadena = 'DOS '
  227.     Case lnUnidades = 3
  228.         lcCadena = 'TRES '
  229.     Case lnUnidades = 4
  230.         lcCadena = 'CUATRO '
  231.     Case lnUnidades = 5
  232.         lcCadena = 'CINCO '
  233.     Case lnUnidades = 6
  234.         lcCadena = 'SEIS '
  235.     Case lnUnidades = 7
  236.         lcCadena = 'SIETE '
  237.     Case lnUnidades = 8
  238.         lcCadena = 'OCHO '
  239.     Case lnUnidades = 9
  240.         lcCadena = 'NUEVE '
  241.     Endcase
  242.  
  243. *--- Analizo las decenas
  244.     Do Case
  245.     Case lnDecenas = 1
  246.         Do Case
  247.         Case lnUnidades = 0
  248.             lcCadena = 'DIEZ '
  249.         Case lnUnidades = 1
  250.             lcCadena = 'ONCE '
  251.         Case lnUnidades = 2
  252.             lcCadena = 'DOCE '
  253.         Case lnUnidades = 3
  254.             lcCadena = 'TRECE '
  255.         Case lnUnidades = 4
  256.             lcCadena = 'CATORCE '
  257.         Case lnUnidades = 5
  258.             lcCadena = 'QUINCE '
  259.         Other
  260.             lcCadena = 'DIECI' + lcCadena
  261.         Endcase
  262.     Case lnDecenas = 2
  263.         lcCadena = Iif(lnUnidades = 0, 'VEINTE ', 'VEINTI') + lcCadena
  264.     Case lnDecenas = 3
  265.         lcCadena = 'TREINTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  266.     Case lnDecenas = 4
  267.         lcCadena = 'CUARENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  268.     Case lnDecenas = 5
  269.         lcCadena = 'CINCUENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  270.     Case lnDecenas = 6
  271.         lcCadena = 'SESENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  272.     Case lnDecenas = 7
  273.         lcCadena = 'SETENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  274.     Case lnDecenas = 8
  275.         lcCadena = 'OCHENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  276.     Case lnDecenas = 9
  277.         lcCadena = 'NOVENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  278.     Endcase
  279.  
  280. *--- Analizo las centenas
  281.     Do Case
  282.     Case lnCentenas = 1
  283.         lcCadena = Iif(lnUnidades = 0 And lnDecenas = 0, ;
  284.             'CIEN ', 'CIENTO ') + lcCadena
  285.     Case lnCentenas = 2
  286.         lcCadena = 'DOSCIENTOS ' + lcCadena
  287.     Case lnCentenas = 3
  288.         lcCadena = 'TRESCIENTOS ' + lcCadena
  289.     Case lnCentenas = 4
  290.         lcCadena = 'CUATROCIENTOS ' + lcCadena
  291.     Case lnCentenas = 5
  292.         lcCadena = 'QUINIENTOS ' + lcCadena
  293.     Case lnCentenas = 6
  294.         lcCadena = 'SEISCIENTOS ' + lcCadena
  295.     Case lnCentenas = 7
  296.         lcCadena = 'SETECIENTOS ' + lcCadena
  297.     Case lnCentenas = 8
  298.         lcCadena = 'OCHOCIENTOS ' + lcCadena
  299.     Case lnCentenas = 9
  300.         lcCadena = 'NOVECIENTOS ' + lcCadena
  301.     Endcase
  302.  
  303. *--- Armo el retorno terna a terna
  304.     lcRetorno = lcCadena + lcMiles + lcRetorno
  305.     lnTerna = lnTerna + 1
  306. Enddo
  307. If lnTerna = 1
  308.     lcRetorno = 'CERO '
  309. Endif
  310. Return lcRetorno
  311. Endfu
  312. *--------------------------------------------------------------------------
  313. * Devuelve un número en letras con centavos
  314. * USO: ? Num2Let(15.11) -> QUINCE CON ONCE CENTAVOS
  315. * RETORNA: Caracter
  316. * AUTOR: LMG
  317. *--------------------------------------------------------------------------
  318. Function Num2Let(tnNumero)
  319. Local lnEntero, lnFraccion
  320. *-- Elegir si se REDONDEA o TRUNCA
  321. * tnNumero = ROUND(tnNumero, 2)  && Redondeo a 2 decimales
  322. tnNumero = Int(tnNumero*100)/100 && Trunco a dos decimales
  323. lnEntero = Int(tnNumero)
  324. lnFraccion = Int((tnNumero - lnEntero) * 100)
  325. Return N2L(lnEntero, 0) + 'CON ' + ;
  326.     N2L(lnFraccion, 1) + 'CENTAVOS.'
  327. Endfunc
  328.  
  329. *--------------------------------------------------------------------------
  330. * FUNCTION N2L(tnNro, tnFlag)
  331. *--------------------------------------------------------------------------
  332. * Devuelve un número entero en letras
  333. * Usada por Let2Num (deben estar ambas)
  334. * USO: ? N2L(32) -> TREINTA Y DOS
  335. * RETORNA: Caracter
  336. * AUTOR: LMG
  337. *--------------------------------------------------------------------------
  338. Function N2L(tnNro, tnFlag)
  339. If Empty(tnFlag)
  340.     tnFlag = 0
  341. Endif
  342. Local lnEntero, lcRetorno, lnTerna, lcMiles, ;
  343.     lcCadena, lnUnidades, lnDecenas, lnCentenas
  344. lnEntero = Int(tnNro)
  345. lcRetorno = ''
  346. lnTerna = 1
  347. Do While lnEntero > 0
  348.     lcCadena = ''
  349.     lnUnidades = Mod(lnEntero, 10)
  350.     lnEntero = Int(lnEntero / 10)
  351.     lnDecenas = Mod(lnEntero, 10)
  352.     lnEntero = Int(lnEntero / 10)
  353.     lnCentenas = Mod(lnEntero, 10)
  354.     lnEntero = Int(lnEntero / 10)
  355.  
  356. *--- Analizo la terna
  357.     Do Case
  358.     Case lnTerna = 1
  359.         lcMiles = ''
  360.     Case lnTerna = 2 And (lnUnidades + lnDecenas + lnCentenas # 0)
  361.         lcMiles = 'MIL '
  362.     Case lnTerna = 3 And (lnUnidades + lnDecenas + lnCentenas # 0)
  363.         lcMiles = Iif(lnUnidades = 1 And lnDecenas = 0 And ;
  364.             lnCentenas = 0, 'MILLON ', 'MILLONES ')
  365.     Case lnTerna = 4 And (lnUnidades + lnDecenas + lnCentenas # 0)
  366.         lcMiles = 'MIL MILLONES '
  367.     Case lnTerna = 5 And (lnUnidades + lnDecenas + lnCentenas # 0)
  368.         lcMiles = Iif(lnUnidades = 1 And lnDecenas = 0 And ;
  369.             lnCentenas = 0, 'BILLON ', 'BILLONES ')
  370.     Case lnTerna > 5
  371.         lcRetorno = ' ERROR: NUMERO DEMASIADO GRANDE '
  372.         Exit
  373.     Endcase
  374.  
  375. *--- Analizo las unidades
  376.     Do Case
  377.     Case lnUnidades = 1
  378.         lcCadena = Iif(lnTerna = 1 And tnFlag = 0, 'UNO ', 'UN ')
  379.     Case lnUnidades = 2
  380.         lcCadena = 'DOS '
  381.     Case lnUnidades = 3
  382.         lcCadena = 'TRES '
  383.     Case lnUnidades = 4
  384.         lcCadena = 'CUATRO '
  385.     Case lnUnidades = 5
  386.         lcCadena = 'CINCO '
  387.     Case lnUnidades = 6
  388.         lcCadena = 'SEIS '
  389.     Case lnUnidades = 7
  390.         lcCadena = 'SIETE '
  391.     Case lnUnidades = 8
  392.         lcCadena = 'OCHO '
  393.     Case lnUnidades = 9
  394.         lcCadena = 'NUEVE '
  395.     Endcase
  396.  
  397. *--- Analizo las decenas
  398.     Do Case
  399.     Case lnDecenas = 1
  400.         Do Case
  401.         Case lnUnidades = 0
  402.             lcCadena = 'DIEZ '
  403.         Case lnUnidades = 1
  404.             lcCadena = 'ONCE '
  405.         Case lnUnidades = 2
  406.             lcCadena = 'DOCE '
  407.         Case lnUnidades = 3
  408.             lcCadena = 'TRECE '
  409.         Case lnUnidades = 4
  410.             lcCadena = 'CATORCE '
  411.         Case lnUnidades = 5
  412.             lcCadena = 'QUINCE '
  413.         Other
  414.             lcCadena = 'DIECI' + lcCadena
  415.         Endcase
  416.     Case lnDecenas = 2
  417.         lcCadena = Iif(lnUnidades = 0, 'VEINTE ', 'VEINTI') + lcCadena
  418.     Case lnDecenas = 3
  419.         lcCadena = 'TREINTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  420.     Case lnDecenas = 4
  421.         lcCadena = 'CUARENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  422.     Case lnDecenas = 5
  423.         lcCadena = 'CINCUENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  424.     Case lnDecenas = 6
  425.         lcCadena = 'SESENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  426.     Case lnDecenas = 7
  427.         lcCadena = 'SETENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  428.     Case lnDecenas = 8
  429.         lcCadena = 'OCHENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  430.     Case lnDecenas = 9
  431.         lcCadena = 'NOVENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  432.     Endcase
  433.  
  434. *--- Analizo las centenas
  435.     Do Case
  436.     Case lnCentenas = 1
  437.         lcCadena = Iif(lnUnidades = 0 And lnDecenas = 0, ;
  438.             'CIEN ', 'CIENTO ') + lcCadena
  439.     Case lnCentenas = 2
  440.         lcCadena = 'DOSCIENTOS ' + lcCadena
  441.     Case lnCentenas = 3
  442.         lcCadena = 'TRESCIENTOS ' + lcCadena
  443.     Case lnCentenas = 4
  444.         lcCadena = 'CUATROCIENTOS ' + lcCadena
  445.     Case lnCentenas = 5
  446.         lcCadena = 'QUINIENTOS ' + lcCadena
  447.     Case lnCentenas = 6
  448.         lcCadena = 'SEISCIENTOS ' + lcCadena
  449.     Case lnCentenas = 7
  450.         lcCadena = 'SETECIENTOS ' + lcCadena
  451.     Case lnCentenas = 8
  452.         lcCadena = 'OCHOCIENTOS ' + lcCadena
  453.     Case lnCentenas = 9
  454.         lcCadena = 'NOVECIENTOS ' + lcCadena
  455.     Endcase
  456.  
  457. *--- Armo el retorno terna a terna
  458.     lcRetorno = lcCadena + lcMiles + lcRetorno
  459.     lnTerna = lnTerna + 1
  460. Enddo
  461. If lnTerna = 1
  462.     lcRetorno = 'CERO '
  463. Endif
  464. Return lcRetorno
  465. Endfu
  466. * Devuelve un número en letras con centavos
  467. * USO: ? Num2Let(15.11) -> QUINCE CON ONCE CENTAVOS
  468. * RETORNA: Caracter
  469. * AUTOR: LMG
  470. *--------------------------------------------------------------------------
  471. Function Num2Let(tnNumero)
  472. Local lnEntero, lnFraccion
  473. *-- Elegir si se REDONDEA o TRUNCA
  474. * tnNumero = ROUND(tnNumero, 2)  && Redondeo a 2 decimales
  475. tnNumero = Int(tnNumero*100)/100 && Trunco a dos decimales
  476. lnEntero = Int(tnNumero)
  477. lnFraccion = Int((tnNumero - lnEntero) * 100)
  478. Return N2L(lnEntero, 0) + 'CON ' + ;
  479.     N2L(lnFraccion, 1) + 'CENTAVOS.'
  480. Endfunc
  481.  
  482. *--------------------------------------------------------------------------
  483. * FUNCTION N2L(tnNro, tnFlag)
  484. *--------------------------------------------------------------------------
  485. * Devuelve un número entero en letras
  486. * Usada por Let2Num (deben estar ambas)
  487. * USO: ? N2L(32) -> TREINTA Y DOS
  488. * RETORNA: Caracter
  489. * AUTOR: LMG
  490. *--------------------------------------------------------------------------
  491. Function N2L(tnNro, tnFlag)
  492. If Empty(tnFlag)
  493.     tnFlag = 0
  494. Endif
  495. Local lnEntero, lcRetorno, lnTerna, lcMiles, ;
  496.     lcCadena, lnUnidades, lnDecenas, lnCentenas
  497. lnEntero = Int(tnNro)
  498. lcRetorno = ''
  499. lnTerna = 1
  500. Do While lnEntero > 0
  501.     lcCadena = ''
  502.     lnUnidades = Mod(lnEntero, 10)
  503.     lnEntero = Int(lnEntero / 10)
  504.     lnDecenas = Mod(lnEntero, 10)
  505.     lnEntero = Int(lnEntero / 10)
  506.     lnCentenas = Mod(lnEntero, 10)
  507.     lnEntero = Int(lnEntero / 10)
  508.  
  509. *--- Analizo la terna
  510.     Do Case
  511.     Case lnTerna = 1
  512.         lcMiles = ''
  513.     Case lnTerna = 2 And (lnUnidades + lnDecenas + lnCentenas # 0)
  514.         lcMiles = 'MIL '
  515.     Case lnTerna = 3 And (lnUnidades + lnDecenas + lnCentenas # 0)
  516.         lcMiles = Iif(lnUnidades = 1 And lnDecenas = 0 And ;
  517.             lnCentenas = 0, 'MILLON ', 'MILLONES ')
  518.     Case lnTerna = 4 And (lnUnidades + lnDecenas + lnCentenas # 0)
  519.         lcMiles = 'MIL MILLONES '
  520.     Case lnTerna = 5 And (lnUnidades + lnDecenas + lnCentenas # 0)
  521.         lcMiles = Iif(lnUnidades = 1 And lnDecenas = 0 And ;
  522.             lnCentenas = 0, 'BILLON ', 'BILLONES ')
  523.     Case lnTerna > 5
  524.         lcRetorno = ' ERROR: NUMERO DEMASIADO GRANDE '
  525.         Exit
  526.     Endcase
  527.  
  528. *--- Analizo las unidades
  529.     Do Case
  530.     Case lnUnidades = 1
  531.         lcCadena = Iif(lnTerna = 1 And tnFlag = 0, 'UNO ', 'UN ')
  532.     Case lnUnidades = 2
  533.         lcCadena = 'DOS '
  534.     Case lnUnidades = 3
  535.         lcCadena = 'TRES '
  536.     Case lnUnidades = 4
  537.         lcCadena = 'CUATRO '
  538.     Case lnUnidades = 5
  539.         lcCadena = 'CINCO '
  540.     Case lnUnidades = 6
  541.         lcCadena = 'SEIS '
  542.     Case lnUnidades = 7
  543.         lcCadena = 'SIETE '
  544.     Case lnUnidades = 8
  545.         lcCadena = 'OCHO '
  546.     Case lnUnidades = 9
  547.         lcCadena = 'NUEVE '
  548.     Endcase
  549.  
  550. *--- Analizo las decenas
  551.     Do Case
  552.     Case lnDecenas = 1
  553.         Do Case
  554.         Case lnUnidades = 0
  555.             lcCadena = 'DIEZ '
  556.         Case lnUnidades = 1
  557.             lcCadena = 'ONCE '
  558.         Case lnUnidades = 2
  559.             lcCadena = 'DOCE '
  560.         Case lnUnidades = 3
  561.             lcCadena = 'TRECE '
  562.         Case lnUnidades = 4
  563.             lcCadena = 'CATORCE '
  564.         Case lnUnidades = 5
  565.             lcCadena = 'QUINCE '
  566.         Other
  567.             lcCadena = 'DIECI' + lcCadena
  568.         Endcase
  569.     Case lnDecenas = 2
  570.         lcCadena = Iif(lnUnidades = 0, 'VEINTE ', 'VEINTI') + lcCadena
  571.     Case lnDecenas = 3
  572.         lcCadena = 'TREINTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  573.     Case lnDecenas = 4
  574.         lcCadena = 'CUARENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  575.     Case lnDecenas = 5
  576.         lcCadena = 'CINCUENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  577.     Case lnDecenas = 6
  578.         lcCadena = 'SESENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  579.     Case lnDecenas = 7
  580.         lcCadena = 'SETENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  581.     Case lnDecenas = 8
  582.         lcCadena = 'OCHENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  583.     Case lnDecenas = 9
  584.         lcCadena = 'NOVENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  585.     Endcase
  586.  
  587. *--- Analizo las centenas
  588.     Do Case
  589.     Case lnCentenas = 1
  590.         lcCadena = Iif(lnUnidades = 0 And lnDecenas = 0, ;
  591.             'CIEN ', 'CIENTO ') + lcCadena
  592.     Case lnCentenas = 2
  593.         lcCadena = 'DOSCIENTOS ' + lcCadena
  594.     Case lnCentenas = 3
  595.         lcCadena = 'TRESCIENTOS ' + lcCadena
  596.     Case lnCentenas = 4
  597.         lcCadena = 'CUATROCIENTOS ' + lcCadena
  598.     Case lnCentenas = 5
  599.         lcCadena = 'QUINIENTOS ' + lcCadena
  600.     Case lnCentenas = 6
  601.         lcCadena = 'SEISCIENTOS ' + lcCadena
  602.     Case lnCentenas = 7
  603.         lcCadena = 'SETECIENTOS ' + lcCadena
  604.     Case lnCentenas = 8
  605.         lcCadena = 'OCHOCIENTOS ' + lcCadena
  606.     Case lnCentenas = 9
  607.         lcCadena = 'NOVECIENTOS ' + lcCadena
  608.     Endcase
  609.  
  610. *--- Armo el retorno terna a terna
  611.     lcRetorno = lcCadena + lcMiles + lcRetorno
  612.     lnTerna = lnTerna + 1
  613. Enddo
  614. If lnTerna = 1
  615.     lcRetorno = 'CERO '
  616. Endif
  617. Return lcRetorno
  618. Endfu
  619. * USO: ? Num2Let(15.11) -> QUINCE CON ONCE CENTAVOS
  620. * RETORNA: Caracter
  621. * AUTOR: LMG
  622. *--------------------------------------------------------------------------
  623. Function Num2Let(tnNumero)
  624. Local lnEntero, lnFraccion
  625. *-- Elegir si se REDONDEA o TRUNCA
  626. * tnNumero = ROUND(tnNumero, 2)  && Redondeo a 2 decimales
  627. tnNumero = Int(tnNumero*100)/100 && Trunco a dos decimales
  628. lnEntero = Int(tnNumero)
  629. lnFraccion = Int((tnNumero - lnEntero) * 100)
  630. Return N2L(lnEntero, 0) + 'CON ' + ;
  631.     N2L(lnFraccion, 1) + 'CENTAVOS.'
  632. Endfunc
  633.  
  634. *--------------------------------------------------------------------------
  635. * FUNCTION N2L(tnNro, tnFlag)
  636. *--------------------------------------------------------------------------
  637. * Devuelve un número entero en letras
  638. * Usada por Let2Num (deben estar ambas)
  639. * USO: ? N2L(32) -> TREINTA Y DOS
  640. * RETORNA: Caracter
  641. * AUTOR: LMG
  642. *--------------------------------------------------------------------------
  643. Function N2L(tnNro, tnFlag)
  644. If Empty(tnFlag)
  645.     tnFlag = 0
  646. Endif
  647. Local lnEntero, lcRetorno, lnTerna, lcMiles, ;
  648.     lcCadena, lnUnidades, lnDecenas, lnCentenas
  649. lnEntero = Int(tnNro)
  650. lcRetorno = ''
  651. lnTerna = 1
  652. Do While lnEntero > 0
  653.     lcCadena = ''
  654.     lnUnidades = Mod(lnEntero, 10)
  655.     lnEntero = Int(lnEntero / 10)
  656.     lnDecenas = Mod(lnEntero, 10)
  657.     lnEntero = Int(lnEntero / 10)
  658.     lnCentenas = Mod(lnEntero, 10)
  659.     lnEntero = Int(lnEntero / 10)
  660.  
  661. *--- Analizo la terna
  662.     Do Case
  663.     Case lnTerna = 1
  664.         lcMiles = ''
  665.     Case lnTerna = 2 And (lnUnidades + lnDecenas + lnCentenas # 0)
  666.         lcMiles = 'MIL '
  667.     Case lnTerna = 3 And (lnUnidades + lnDecenas + lnCentenas # 0)
  668.         lcMiles = Iif(lnUnidades = 1 And lnDecenas = 0 And ;
  669.             lnCentenas = 0, 'MILLON ', 'MILLONES ')
  670.     Case lnTerna = 4 And (lnUnidades + lnDecenas + lnCentenas # 0)
  671.         lcMiles = 'MIL MILLONES '
  672.     Case lnTerna = 5 And (lnUnidades + lnDecenas + lnCentenas # 0)
  673.         lcMiles = Iif(lnUnidades = 1 And lnDecenas = 0 And ;
  674.             lnCentenas = 0, 'BILLON ', 'BILLONES ')
  675.     Case lnTerna > 5
  676.         lcRetorno = ' ERROR: NUMERO DEMASIADO GRANDE '
  677.         Exit
  678.     Endcase
  679.  
  680. *--- Analizo las unidades
  681.     Do Case
  682.     Case lnUnidades = 1
  683.         lcCadena = Iif(lnTerna = 1 And tnFlag = 0, 'UNO ', 'UN ')
  684.     Case lnUnidades = 2
  685.         lcCadena = 'DOS '
  686.     Case lnUnidades = 3
  687.         lcCadena = 'TRES '
  688.     Case lnUnidades = 4
  689.         lcCadena = 'CUATRO '
  690.     Case lnUnidades = 5
  691.         lcCadena = 'CINCO '
  692.     Case lnUnidades = 6
  693.         lcCadena = 'SEIS '
  694.     Case lnUnidades = 7
  695.         lcCadena = 'SIETE '
  696.     Case lnUnidades = 8
  697.         lcCadena = 'OCHO '
  698.     Case lnUnidades = 9
  699.         lcCadena = 'NUEVE '
  700.     Endcase
  701.  
  702. *--- Analizo las decenas
  703.     Do Case
  704.     Case lnDecenas = 1
  705.         Do Case
  706.         Case lnUnidades = 0
  707.             lcCadena = 'DIEZ '
  708.         Case lnUnidades = 1
  709.             lcCadena = 'ONCE '
  710.         Case lnUnidades = 2
  711.             lcCadena = 'DOCE '
  712.         Case lnUnidades = 3
  713.             lcCadena = 'TRECE '
  714.         Case lnUnidades = 4
  715.             lcCadena = 'CATORCE '
  716.         Case lnUnidades = 5
  717.             lcCadena = 'QUINCE '
  718.         Other
  719.             lcCadena = 'DIECI' + lcCadena
  720.         Endcase
  721.     Case lnDecenas = 2
  722.         lcCadena = Iif(lnUnidades = 0, 'VEINTE ', 'VEINTI') + lcCadena
  723.     Case lnDecenas = 3
  724.         lcCadena = 'TREINTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  725.     Case lnDecenas = 4
  726.         lcCadena = 'CUARENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  727.     Case lnDecenas = 5
  728.         lcCadena = 'CINCUENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  729.     Case lnDecenas = 6
  730.         lcCadena = 'SESENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  731.     Case lnDecenas = 7
  732.         lcCadena = 'SETENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  733.     Case lnDecenas = 8
  734.         lcCadena = 'OCHENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  735.     Case lnDecenas = 9
  736.         lcCadena = 'NOVENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  737.     Endcase
  738.  
  739. *--- Analizo las centenas
  740.     Do Case
  741.     Case lnCentenas = 1
  742.         lcCadena = Iif(lnUnidades = 0 And lnDecenas = 0, ;
  743.             'CIEN ', 'CIENTO ') + lcCadena
  744.     Case lnCentenas = 2
  745.         lcCadena = 'DOSCIENTOS ' + lcCadena
  746.     Case lnCentenas = 3
  747.         lcCadena = 'TRESCIENTOS ' + lcCadena
  748.     Case lnCentenas = 4
  749.         lcCadena = 'CUATROCIENTOS ' + lcCadena
  750.     Case lnCentenas = 5
  751.         lcCadena = 'QUINIENTOS ' + lcCadena
  752.     Case lnCentenas = 6
  753.         lcCadena = 'SEISCIENTOS ' + lcCadena
  754.     Case lnCentenas = 7
  755.         lcCadena = 'SETECIENTOS ' + lcCadena
  756.     Case lnCentenas = 8
  757.         lcCadena = 'OCHOCIENTOS ' + lcCadena
  758.     Case lnCentenas = 9
  759.         lcCadena = 'NOVECIENTOS ' + lcCadena
  760.     Endcase
  761.  
  762. *--- Armo el retorno terna a terna
  763.     lcRetorno = lcCadena + lcMiles + lcRetorno
  764.     lnTerna = lnTerna + 1
  765. Enddo
  766. If lnTerna = 1
  767.     lcRetorno = 'CERO '
  768. Endif
  769. Return lcRetorno
  770. Endfu
  771. * RETORNA: Caracter
  772. * AUTOR: LMG
  773. *--------------------------------------------------------------------------
  774. Function Num2Let(tnNumero)
  775. Local lnEntero, lnFraccion
  776. *-- Elegir si se REDONDEA o TRUNCA
  777. * tnNumero = ROUND(tnNumero, 2)  && Redondeo a 2 decimales
  778. tnNumero = Int(tnNumero*100)/100 && Trunco a dos decimales
  779. lnEntero = Int(tnNumero)
  780. lnFraccion = Int((tnNumero - lnEntero) * 100)
  781. Return N2L(lnEntero, 0) + 'CON ' + ;
  782.     N2L(lnFraccion, 1) + 'CENTAVOS.'
  783. Endfunc
  784.  
  785. *--------------------------------------------------------------------------
  786. * FUNCTION N2L(tnNro, tnFlag)
  787. *--------------------------------------------------------------------------
  788. * Devuelve un número entero en letras
  789. * Usada por Let2Num (deben estar ambas)
  790. * USO: ? N2L(32) -> TREINTA Y DOS
  791. * RETORNA: Caracter
  792. * AUTOR: LMG
  793. *--------------------------------------------------------------------------
  794. Function N2L(tnNro, tnFlag)
  795. If Empty(tnFlag)
  796.     tnFlag = 0
  797. Endif
  798. Local lnEntero, lcRetorno, lnTerna, lcMiles, ;
  799.     lcCadena, lnUnidades, lnDecenas, lnCentenas
  800. lnEntero = Int(tnNro)
  801. lcRetorno = ''
  802. lnTerna = 1
  803. Do While lnEntero > 0
  804.     lcCadena = ''
  805.     lnUnidades = Mod(lnEntero, 10)
  806.     lnEntero = Int(lnEntero / 10)
  807.     lnDecenas = Mod(lnEntero, 10)
  808.     lnEntero = Int(lnEntero / 10)
  809.     lnCentenas = Mod(lnEntero, 10)
  810.     lnEntero = Int(lnEntero / 10)
  811.  
  812. *--- Analizo la terna
  813.     Do Case
  814.     Case lnTerna = 1
  815.         lcMiles = ''
  816.     Case lnTerna = 2 And (lnUnidades + lnDecenas + lnCentenas # 0)
  817.         lcMiles = 'MIL '
  818.     Case lnTerna = 3 And (lnUnidades + lnDecenas + lnCentenas # 0)
  819.         lcMiles = Iif(lnUnidades = 1 And lnDecenas = 0 And ;
  820.             lnCentenas = 0, 'MILLON ', 'MILLONES ')
  821.     Case lnTerna = 4 And (lnUnidades + lnDecenas + lnCentenas # 0)
  822.         lcMiles = 'MIL MILLONES '
  823.     Case lnTerna = 5 And (lnUnidades + lnDecenas + lnCentenas # 0)
  824.         lcMiles = Iif(lnUnidades = 1 And lnDecenas = 0 And ;
  825.             lnCentenas = 0, 'BILLON ', 'BILLONES ')
  826.     Case lnTerna > 5
  827.         lcRetorno = ' ERROR: NUMERO DEMASIADO GRANDE '
  828.         Exit
  829.     Endcase
  830.  
  831. *--- Analizo las unidades
  832.     Do Case
  833.     Case lnUnidades = 1
  834.         lcCadena = Iif(lnTerna = 1 And tnFlag = 0, 'UNO ', 'UN ')
  835.     Case lnUnidades = 2
  836.         lcCadena = 'DOS '
  837.     Case lnUnidades = 3
  838.         lcCadena = 'TRES '
  839.     Case lnUnidades = 4
  840.         lcCadena = 'CUATRO '
  841.     Case lnUnidades = 5
  842.         lcCadena = 'CINCO '
  843.     Case lnUnidades = 6
  844.         lcCadena = 'SEIS '
  845.     Case lnUnidades = 7
  846.         lcCadena = 'SIETE '
  847.     Case lnUnidades = 8
  848.         lcCadena = 'OCHO '
  849.     Case lnUnidades = 9
  850.         lcCadena = 'NUEVE '
  851.     Endcase
  852.  
  853. *--- Analizo las decenas
  854.     Do Case
  855.     Case lnDecenas = 1
  856.         Do Case
  857.         Case lnUnidades = 0
  858.             lcCadena = 'DIEZ '
  859.         Case lnUnidades = 1
  860.             lcCadena = 'ONCE '
  861.         Case lnUnidades = 2
  862.             lcCadena = 'DOCE '
  863.         Case lnUnidades = 3
  864.             lcCadena = 'TRECE '
  865.         Case lnUnidades = 4
  866.             lcCadena = 'CATORCE '
  867.         Case lnUnidades = 5
  868.             lcCadena = 'QUINCE '
  869.         Other
  870.             lcCadena = 'DIECI' + lcCadena
  871.         Endcase
  872.     Case lnDecenas = 2
  873.         lcCadena = Iif(lnUnidades = 0, 'VEINTE ', 'VEINTI') + lcCadena
  874.     Case lnDecenas = 3
  875.         lcCadena = 'TREINTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  876.     Case lnDecenas = 4
  877.         lcCadena = 'CUARENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  878.     Case lnDecenas = 5
  879.         lcCadena = 'CINCUENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  880.     Case lnDecenas = 6
  881.         lcCadena = 'SESENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  882.     Case lnDecenas = 7
  883.         lcCadena = 'SETENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  884.     Case lnDecenas = 8
  885.         lcCadena = 'OCHENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  886.     Case lnDecenas = 9
  887.         lcCadena = 'NOVENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  888.     Endcase
  889.  
  890. *--- Analizo las centenas
  891.     Do Case
  892.     Case lnCentenas = 1
  893.         lcCadena = Iif(lnUnidades = 0 And lnDecenas = 0, ;
  894.             'CIEN ', 'CIENTO ') + lcCadena
  895.     Case lnCentenas = 2
  896.         lcCadena = 'DOSCIENTOS ' + lcCadena
  897.     Case lnCentenas = 3
  898.         lcCadena = 'TRESCIENTOS ' + lcCadena
  899.     Case lnCentenas = 4
  900.         lcCadena = 'CUATROCIENTOS ' + lcCadena
  901.     Case lnCentenas = 5
  902.         lcCadena = 'QUINIENTOS ' + lcCadena
  903.     Case lnCentenas = 6
  904.         lcCadena = 'SEISCIENTOS ' + lcCadena
  905.     Case lnCentenas = 7
  906.         lcCadena = 'SETECIENTOS ' + lcCadena
  907.     Case lnCentenas = 8
  908.         lcCadena = 'OCHOCIENTOS ' + lcCadena
  909.     Case lnCentenas = 9
  910.         lcCadena = 'NOVECIENTOS ' + lcCadena
  911.     Endcase
  912.  
  913. *--- Armo el retorno terna a terna
  914.     lcRetorno = lcCadena + lcMiles + lcRetorno
  915.     lnTerna = lnTerna + 1
  916. Enddo
  917. If lnTerna = 1
  918.     lcRetorno = 'CERO '
  919. Endif
  920. Return lcRetorno
  921. Endfu
  922. * AUTOR: LMG
  923. *--------------------------------------------------------------------------
  924. Function Num2Let(tnNumero)
  925. Local lnEntero, lnFraccion
  926. *-- Elegir si se REDONDEA o TRUNCA
  927. * tnNumero = ROUND(tnNumero, 2)  && Redondeo a 2 decimales
  928. tnNumero = Int(tnNumero*100)/100 && Trunco a dos decimales
  929. lnEntero = Int(tnNumero)
  930. lnFraccion = Int((tnNumero - lnEntero) * 100)
  931. Return N2L(lnEntero, 0) + 'CON ' + ;
  932.     N2L(lnFraccion, 1) + 'CENTAVOS.'
  933. Endfunc
  934.  
  935. *--------------------------------------------------------------------------
  936. * FUNCTION N2L(tnNro, tnFlag)
  937. *--------------------------------------------------------------------------
  938. * Devuelve un número entero en letras
  939. * Usada por Let2Num (deben estar ambas)
  940. * USO: ? N2L(32) -> TREINTA Y DOS
  941. * RETORNA: Caracter
  942. * AUTOR: LMG
  943. *--------------------------------------------------------------------------
  944. Function N2L(tnNro, tnFlag)
  945. If Empty(tnFlag)
  946.     tnFlag = 0
  947. Endif
  948. Local lnEntero, lcRetorno, lnTerna, lcMiles, ;
  949.     lcCadena, lnUnidades, lnDecenas, lnCentenas
  950. lnEntero = Int(tnNro)
  951. lcRetorno = ''
  952. lnTerna = 1
  953. Do While lnEntero > 0
  954.     lcCadena = ''
  955.     lnUnidades = Mod(lnEntero, 10)
  956.     lnEntero = Int(lnEntero / 10)
  957.     lnDecenas = Mod(lnEntero, 10)
  958.     lnEntero = Int(lnEntero / 10)
  959.     lnCentenas = Mod(lnEntero, 10)
  960.     lnEntero = Int(lnEntero / 10)
  961.  
  962. *--- Analizo la terna
  963.     Do Case
  964.     Case lnTerna = 1
  965.         lcMiles = ''
  966.     Case lnTerna = 2 And (lnUnidades + lnDecenas + lnCentenas # 0)
  967.         lcMiles = 'MIL '
  968.     Case lnTerna = 3 And (lnUnidades + lnDecenas + lnCentenas # 0)
  969.         lcMiles = Iif(lnUnidades = 1 And lnDecenas = 0 And ;
  970.             lnCentenas = 0, 'MILLON ', 'MILLONES ')
  971.     Case lnTerna = 4 And (lnUnidades + lnDecenas + lnCentenas # 0)
  972.         lcMiles = 'MIL MILLONES '
  973.     Case lnTerna = 5 And (lnUnidades + lnDecenas + lnCentenas # 0)
  974.         lcMiles = Iif(lnUnidades = 1 And lnDecenas = 0 And ;
  975.             lnCentenas = 0, 'BILLON ', 'BILLONES ')
  976.     Case lnTerna > 5
  977.         lcRetorno = ' ERROR: NUMERO DEMASIADO GRANDE '
  978.         Exit
  979.     Endcase
  980.  
  981. *--- Analizo las unidades
  982.     Do Case
  983.     Case lnUnidades = 1
  984.         lcCadena = Iif(lnTerna = 1 And tnFlag = 0, 'UNO ', 'UN ')
  985.     Case lnUnidades = 2
  986.         lcCadena = 'DOS '
  987.     Case lnUnidades = 3
  988.         lcCadena = 'TRES '
  989.     Case lnUnidades = 4
  990.         lcCadena = 'CUATRO '
  991.     Case lnUnidades = 5
  992.         lcCadena = 'CINCO '
  993.     Case lnUnidades = 6
  994.         lcCadena = 'SEIS '
  995.     Case lnUnidades = 7
  996.         lcCadena = 'SIETE '
  997.     Case lnUnidades = 8
  998.         lcCadena = 'OCHO '
  999.     Case lnUnidades = 9
  1000.         lcCadena = 'NUEVE '
  1001.     Endcase
  1002.  
  1003. *--- Analizo las decenas
  1004.     Do Case
  1005.     Case lnDecenas = 1
  1006.         Do Case
  1007.         Case lnUnidades = 0
  1008.             lcCadena = 'DIEZ '
  1009.         Case lnUnidades = 1
  1010.             lcCadena = 'ONCE '
  1011.         Case lnUnidades = 2
  1012.             lcCadena = 'DOCE '
  1013.         Case lnUnidades = 3
  1014.             lcCadena = 'TRECE '
  1015.         Case lnUnidades = 4
  1016.             lcCadena = 'CATORCE '
  1017.         Case lnUnidades = 5
  1018.             lcCadena = 'QUINCE '
  1019.         Other
  1020.             lcCadena = 'DIECI' + lcCadena
  1021.         Endcase
  1022.     Case lnDecenas = 2
  1023.         lcCadena = Iif(lnUnidades = 0, 'VEINTE ', 'VEINTI') + lcCadena
  1024.     Case lnDecenas = 3
  1025.         lcCadena = 'TREINTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  1026.     Case lnDecenas = 4
  1027.         lcCadena = 'CUARENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  1028.     Case lnDecenas = 5
  1029.         lcCadena = 'CINCUENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  1030.     Case lnDecenas = 6
  1031.         lcCadena = 'SESENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  1032.     Case lnDecenas = 7
  1033.         lcCadena = 'SETENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  1034.     Case lnDecenas = 8
  1035.         lcCadena = 'OCHENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  1036.     Case lnDecenas = 9
  1037.         lcCadena = 'NOVENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  1038.     Endcase
  1039.  
  1040. *--- Analizo las centenas
  1041.     Do Case
  1042.     Case lnCentenas = 1
  1043.         lcCadena = Iif(lnUnidades = 0 And lnDecenas = 0, ;
  1044.             'CIEN ', 'CIENTO ') + lcCadena
  1045.     Case lnCentenas = 2
  1046.         lcCadena = 'DOSCIENTOS ' + lcCadena
  1047.     Case lnCentenas = 3
  1048.         lcCadena = 'TRESCIENTOS ' + lcCadena
  1049.     Case lnCentenas = 4
  1050.         lcCadena = 'CUATROCIENTOS ' + lcCadena
  1051.     Case lnCentenas = 5
  1052.         lcCadena = 'QUINIENTOS ' + lcCadena
  1053.     Case lnCentenas = 6
  1054.         lcCadena = 'SEISCIENTOS ' + lcCadena
  1055.     Case lnCentenas = 7
  1056.         lcCadena = 'SETECIENTOS ' + lcCadena
  1057.     Case lnCentenas = 8
  1058.         lcCadena = 'OCHOCIENTOS ' + lcCadena
  1059.     Case lnCentenas = 9
  1060.         lcCadena = 'NOVECIENTOS ' + lcCadena
  1061.     Endcase
  1062.  
  1063. *--- Armo el retorno terna a terna
  1064.     lcRetorno = lcCadena + lcMiles + lcRetorno
  1065.     lnTerna = lnTerna + 1
  1066. Enddo
  1067. If lnTerna = 1
  1068.     lcRetorno = 'CERO '
  1069. Endif
  1070. Return lcRetorno
  1071. Endfu
  1072. *--------------------------------------------------------------------------
  1073. Function Num2Let(tnNumero)
  1074. Local lnEntero, lnFraccion
  1075. *-- Elegir si se REDONDEA o TRUNCA
  1076. * tnNumero = ROUND(tnNumero, 2)  && Redondeo a 2 decimales
  1077. tnNumero = Int(tnNumero*100)/100 && Trunco a dos decimales
  1078. lnEntero = Int(tnNumero)
  1079. lnFraccion = Int((tnNumero - lnEntero) * 100)
  1080. Return N2L(lnEntero, 0) + 'CON ' + ;
  1081.     N2L(lnFraccion, 1) + 'CENTAVOS.'
  1082. Endfunc
  1083.  
  1084. *--------------------------------------------------------------------------
  1085. * FUNCTION N2L(tnNro, tnFlag)
  1086. *--------------------------------------------------------------------------
  1087. * Devuelve un número entero en letras
  1088. * Usada por Let2Num (deben estar ambas)
  1089. * USO: ? N2L(32) -> TREINTA Y DOS
  1090. * RETORNA: Caracter
  1091. * AUTOR: LMG
  1092. *--------------------------------------------------------------------------
  1093. Function N2L(tnNro, tnFlag)
  1094. If Empty(tnFlag)
  1095.     tnFlag = 0
  1096. Endif
  1097. Local lnEntero, lcRetorno, lnTerna, lcMiles, ;
  1098.     lcCadena, lnUnidades, lnDecenas, lnCentenas
  1099. lnEntero = Int(tnNro)
  1100. lcRetorno = ''
  1101. lnTerna = 1
  1102. Do While lnEntero > 0
  1103.     lcCadena = ''
  1104.     lnUnidades = Mod(lnEntero, 10)
  1105.     lnEntero = Int(lnEntero / 10)
  1106.     lnDecenas = Mod(lnEntero, 10)
  1107.     lnEntero = Int(lnEntero / 10)
  1108.     lnCentenas = Mod(lnEntero, 10)
  1109.     lnEntero = Int(lnEntero / 10)
  1110.  
  1111. *--- Analizo la terna
  1112.     Do Case
  1113.     Case lnTerna = 1
  1114.         lcMiles = ''
  1115.     Case lnTerna = 2 And (lnUnidades + lnDecenas + lnCentenas # 0)
  1116.         lcMiles = 'MIL '
  1117.     Case lnTerna = 3 And (lnUnidades + lnDecenas + lnCentenas # 0)
  1118.         lcMiles = Iif(lnUnidades = 1 And lnDecenas = 0 And ;
  1119.             lnCentenas = 0, 'MILLON ', 'MILLONES ')
  1120.     Case lnTerna = 4 And (lnUnidades + lnDecenas + lnCentenas # 0)
  1121.         lcMiles = 'MIL MILLONES '
  1122.     Case lnTerna = 5 And (lnUnidades + lnDecenas + lnCentenas # 0)
  1123.         lcMiles = Iif(lnUnidades = 1 And lnDecenas = 0 And ;
  1124.             lnCentenas = 0, 'BILLON ', 'BILLONES ')
  1125.     Case lnTerna > 5
  1126.         lcRetorno = ' ERROR: NUMERO DEMASIADO GRANDE '
  1127.         Exit
  1128.     Endcase
  1129.  
  1130. *--- Analizo las unidades
  1131.     Do Case
  1132.     Case lnUnidades = 1
  1133.         lcCadena = Iif(lnTerna = 1 And tnFlag = 0, 'UNO ', 'UN ')
  1134.     Case lnUnidades = 2
  1135.         lcCadena = 'DOS '
  1136.     Case lnUnidades = 3
  1137.         lcCadena = 'TRES '
  1138.     Case lnUnidades = 4
  1139.         lcCadena = 'CUATRO '
  1140.     Case lnUnidades = 5
  1141.         lcCadena = 'CINCO '
  1142.     Case lnUnidades = 6
  1143.         lcCadena = 'SEIS '
  1144.     Case lnUnidades = 7
  1145.         lcCadena = 'SIETE '
  1146.     Case lnUnidades = 8
  1147.         lcCadena = 'OCHO '
  1148.     Case lnUnidades = 9
  1149.         lcCadena = 'NUEVE '
  1150.     Endcase
  1151.  
  1152. *--- Analizo las decenas
  1153.     Do Case
  1154.     Case lnDecenas = 1
  1155.         Do Case
  1156.         Case lnUnidades = 0
  1157.             lcCadena = 'DIEZ '
  1158.         Case lnUnidades = 1
  1159.             lcCadena = 'ONCE '
  1160.         Case lnUnidades = 2
  1161.             lcCadena = 'DOCE '
  1162.         Case lnUnidades = 3
  1163.             lcCadena = 'TRECE '
  1164.         Case lnUnidades = 4
  1165.             lcCadena = 'CATORCE '
  1166.         Case lnUnidades = 5
  1167.             lcCadena = 'QUINCE '
  1168.         Other
  1169.             lcCadena = 'DIECI' + lcCadena
  1170.         Endcase
  1171.     Case lnDecenas = 2
  1172.         lcCadena = Iif(lnUnidades = 0, 'VEINTE ', 'VEINTI') + lcCadena
  1173.     Case lnDecenas = 3
  1174.         lcCadena = 'TREINTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  1175.     Case lnDecenas = 4
  1176.         lcCadena = 'CUARENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  1177.     Case lnDecenas = 5
  1178.         lcCadena = 'CINCUENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  1179.     Case lnDecenas = 6
  1180.         lcCadena = 'SESENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  1181.     Case lnDecenas = 7
  1182.         lcCadena = 'SETENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  1183.     Case lnDecenas = 8
  1184.         lcCadena = 'OCHENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  1185.     Case lnDecenas = 9
  1186.         lcCadena = 'NOVENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  1187.     Endcase
  1188.  
  1189. *--- Analizo las centenas
  1190.     Do Case
  1191.     Case lnCentenas = 1
  1192.         lcCadena = Iif(lnUnidades = 0 And lnDecenas = 0, ;
  1193.             'CIEN ', 'CIENTO ') + lcCadena
  1194.     Case lnCentenas = 2
  1195.         lcCadena = 'DOSCIENTOS ' + lcCadena
  1196.     Case lnCentenas = 3
  1197.         lcCadena = 'TRESCIENTOS ' + lcCadena
  1198.     Case lnCentenas = 4
  1199.         lcCadena = 'CUATROCIENTOS ' + lcCadena
  1200.     Case lnCentenas = 5
  1201.         lcCadena = 'QUINIENTOS ' + lcCadena
  1202.     Case lnCentenas = 6
  1203.         lcCadena = 'SEISCIENTOS ' + lcCadena
  1204.     Case lnCentenas = 7
  1205.         lcCadena = 'SETECIENTOS ' + lcCadena
  1206.     Case lnCentenas = 8
  1207.         lcCadena = 'OCHOCIENTOS ' + lcCadena
  1208.     Case lnCentenas = 9
  1209.         lcCadena = 'NOVECIENTOS ' + lcCadena
  1210.     Endcase
  1211.  
  1212. *--- Armo el retorno terna a terna
  1213.     lcRetorno = lcCadena + lcMiles + lcRetorno
  1214.     lnTerna = lnTerna + 1
  1215. Enddo
  1216. If lnTerna = 1
  1217.     lcRetorno = 'CERO '
  1218. Endif
  1219. Return lcRetorno
  1220. Endfu
  1221. *-- Elegir si se REDONDEA o TRUNCA
  1222. * tnNumero = ROUND(tnNumero, 2)  && Redondeo a 2 decimales
  1223. tnNumero = Int(tnNumero*100)/100 && Trunco a dos decimales
  1224. lnEntero = Int(tnNumero)
  1225. lnFraccion = Int((tnNumero - lnEntero) * 100)
  1226. Return N2L(lnEntero, 0) + 'CON ' + ;
  1227.     N2L(lnFraccion, 1) + 'CENTAVOS.'
  1228. Endfunc
  1229.  
  1230. *--------------------------------------------------------------------------
  1231. * FUNCTION N2L(tnNro, tnFlag)
  1232. *--------------------------------------------------------------------------
  1233. * Devuelve un número entero en letras
  1234. * Usada por Let2Num (deben estar ambas)
  1235. * USO: ? N2L(32) -> TREINTA Y DOS
  1236. * RETORNA: Caracter
  1237. * AUTOR: LMG
  1238. *--------------------------------------------------------------------------
  1239. Function N2L(tnNro, tnFlag)
  1240. If Empty(tnFlag)
  1241.     tnFlag = 0
  1242. Endif
  1243. Local lnEntero, lcRetorno, lnTerna, lcMiles, ;
  1244.     lcCadena, lnUnidades, lnDecenas, lnCentenas
  1245. lnEntero = Int(tnNro)
  1246. lcRetorno = ''
  1247. lnTerna = 1
  1248. Do While lnEntero > 0
  1249.     lcCadena = ''
  1250.     lnUnidades = Mod(lnEntero, 10)
  1251.     lnEntero = Int(lnEntero / 10)
  1252.     lnDecenas = Mod(lnEntero, 10)
  1253.     lnEntero = Int(lnEntero / 10)
  1254.     lnCentenas = Mod(lnEntero, 10)
  1255.     lnEntero = Int(lnEntero / 10)
  1256.  
  1257. *--- Analizo la terna
  1258.     Do Case
  1259.     Case lnTerna = 1
  1260.         lcMiles = ''
  1261.     Case lnTerna = 2 And (lnUnidades + lnDecenas + lnCentenas # 0)
  1262.         lcMiles = 'MIL '
  1263.     Case lnTerna = 3 And (lnUnidades + lnDecenas + lnCentenas # 0)
  1264.         lcMiles = Iif(lnUnidades = 1 And lnDecenas = 0 And ;
  1265.             lnCentenas = 0, 'MILLON ', 'MILLONES ')
  1266.     Case lnTerna = 4 And (lnUnidades + lnDecenas + lnCentenas # 0)
  1267.         lcMiles = 'MIL MILLONES '
  1268.     Case lnTerna = 5 And (lnUnidades + lnDecenas + lnCentenas # 0)
  1269.         lcMiles = Iif(lnUnidades = 1 And lnDecenas = 0 And ;
  1270.             lnCentenas = 0, 'BILLON ', 'BILLONES ')
  1271.     Case lnTerna > 5
  1272.         lcRetorno = ' ERROR: NUMERO DEMASIADO GRANDE '
  1273.         Exit
  1274.     Endcase
  1275.  
  1276. *--- Analizo las unidades
  1277.     Do Case
  1278.     Case lnUnidades = 1
  1279.         lcCadena = Iif(lnTerna = 1 And tnFlag = 0, 'UNO ', 'UN ')
  1280.     Case lnUnidades = 2
  1281.         lcCadena = 'DOS '
  1282.     Case lnUnidades = 3
  1283.         lcCadena = 'TRES '
  1284.     Case lnUnidades = 4
  1285.         lcCadena = 'CUATRO '
  1286.     Case lnUnidades = 5
  1287.         lcCadena = 'CINCO '
  1288.     Case lnUnidades = 6
  1289.         lcCadena = 'SEIS '
  1290.     Case lnUnidades = 7
  1291.         lcCadena = 'SIETE '
  1292.     Case lnUnidades = 8
  1293.         lcCadena = 'OCHO '
  1294.     Case lnUnidades = 9
  1295.         lcCadena = 'NUEVE '
  1296.     Endcase
  1297.  
  1298. *--- Analizo las decenas
  1299.     Do Case
  1300.     Case lnDecenas = 1
  1301.         Do Case
  1302.         Case lnUnidades = 0
  1303.             lcCadena = 'DIEZ '
  1304.         Case lnUnidades = 1
  1305.             lcCadena = 'ONCE '
  1306.         Case lnUnidades = 2
  1307.             lcCadena = 'DOCE '
  1308.         Case lnUnidades = 3
  1309.             lcCadena = 'TRECE '
  1310.         Case lnUnidades = 4
  1311.             lcCadena = 'CATORCE '
  1312.         Case lnUnidades = 5
  1313.             lcCadena = 'QUINCE '
  1314.         Other
  1315.             lcCadena = 'DIECI' + lcCadena
  1316.         Endcase
  1317.     Case lnDecenas = 2
  1318.         lcCadena = Iif(lnUnidades = 0, 'VEINTE ', 'VEINTI') + lcCadena
  1319.     Case lnDecenas = 3
  1320.         lcCadena = 'TREINTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  1321.     Case lnDecenas = 4
  1322.         lcCadena = 'CUARENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  1323.     Case lnDecenas = 5
  1324.         lcCadena = 'CINCUENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  1325.     Case lnDecenas = 6
  1326.         lcCadena = 'SESENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  1327.     Case lnDecenas = 7
  1328.         lcCadena = 'SETENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  1329.     Case lnDecenas = 8
  1330.         lcCadena = 'OCHENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  1331.     Case lnDecenas = 9
  1332.         lcCadena = 'NOVENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  1333.     Endcase
  1334.  
  1335. *--- Analizo las centenas
  1336.     Do Case
  1337.     Case lnCentenas = 1
  1338.         lcCadena = Iif(lnUnidades = 0 And lnDecenas = 0, ;
  1339.             'CIEN ', 'CIENTO ') + lcCadena
  1340.     Case lnCentenas = 2
  1341.         lcCadena = 'DOSCIENTOS ' + lcCadena
  1342.     Case lnCentenas = 3
  1343.         lcCadena = 'TRESCIENTOS ' + lcCadena
  1344.     Case lnCentenas = 4
  1345.         lcCadena = 'CUATROCIENTOS ' + lcCadena
  1346.     Case lnCentenas = 5
  1347.         lcCadena = 'QUINIENTOS ' + lcCadena
  1348.     Case lnCentenas = 6
  1349.         lcCadena = 'SEISCIENTOS ' + lcCadena
  1350.     Case lnCentenas = 7
  1351.         lcCadena = 'SETECIENTOS ' + lcCadena
  1352.     Case lnCentenas = 8
  1353.         lcCadena = 'OCHOCIENTOS ' + lcCadena
  1354.     Case lnCentenas = 9
  1355.         lcCadena = 'NOVECIENTOS ' + lcCadena
  1356.     Endcase
  1357.  
  1358. *--- Armo el retorno terna a terna
  1359.     lcRetorno = lcCadena + lcMiles + lcRetorno
  1360.     lnTerna = lnTerna + 1
  1361. Enddo
  1362. If lnTerna = 1
  1363.     lcRetorno = 'CERO '
  1364. Endif
  1365. Return lcRetorno
  1366. Endfu
  1367. * tnNumero = ROUND(tnNumero, 2)  && Redondeo a 2 decimales
  1368. tnNumero = Int(tnNumero*100)/100 && Trunco a dos decimales
  1369. lnEntero = Int(tnNumero)
  1370. lnFraccion = Int((tnNumero - lnEntero) * 100)
  1371. Return N2L(lnEntero, 0) + 'CON ' + ;
  1372.     N2L(lnFraccion, 1) + 'CENTAVOS.'
  1373. Endfunc
  1374. *--------------------------------------------------------------------------
  1375. * FUNCTION N2L(tnNro, tnFlag)
  1376. *--------------------------------------------------------------------------
  1377. * Devuelve un número entero en letras
  1378. * Usada por Let2Num (deben estar ambas)
  1379. * USO: ? N2L(32) -> TREINTA Y DOS
  1380. * RETORNA: Caracter
  1381. * AUTOR: LMG
  1382. *--------------------------------------------------------------------------
  1383. Function N2L(tnNro, tnFlag)
  1384. If Empty(tnFlag)
  1385.     tnFlag = 0
  1386. Endif
  1387. Local lnEntero, lcRetorno, lnTerna, lcMiles, ;
  1388.     lcCadena, lnUnidades, lnDecenas, lnCentenas
  1389. lnEntero = Int(tnNro)
  1390. lcRetorno = ''
  1391. lnTerna = 1
  1392. Do While lnEntero > 0
  1393.     lcCadena = ''
  1394.     lnUnidades = Mod(lnEntero, 10)
  1395.     lnEntero = Int(lnEntero / 10)
  1396.     lnDecenas = Mod(lnEntero, 10)
  1397.     lnEntero = Int(lnEntero / 10)
  1398.     lnCentenas = Mod(lnEntero, 10)
  1399.     lnEntero = Int(lnEntero / 10)
  1400.  
  1401. *--- Analizo la terna
  1402.     Do Case
  1403.     Case lnTerna = 1
  1404.         lcMiles = ''
  1405.     Case lnTerna = 2 And (lnUnidades + lnDecenas + lnCentenas # 0)
  1406.         lcMiles = 'MIL '
  1407.     Case lnTerna = 3 And (lnUnidades + lnDecenas + lnCentenas # 0)
  1408.         lcMiles = Iif(lnUnidades = 1 And lnDecenas = 0 And ;
  1409.             lnCentenas = 0, 'MILLON ', 'MILLONES ')
  1410.     Case lnTerna = 4 And (lnUnidades + lnDecenas + lnCentenas # 0)
  1411.         lcMiles = 'MIL MILLONES '
  1412.     Case lnTerna = 5 And (lnUnidades + lnDecenas + lnCentenas # 0)
  1413.         lcMiles = Iif(lnUnidades = 1 And lnDecenas = 0 And ;
  1414.             lnCentenas = 0, 'BILLON ', 'BILLONES ')
  1415.     Case lnTerna > 5
  1416.         lcRetorno = ' ERROR: NUMERO DEMASIADO GRANDE '
  1417.         Exit
  1418.     Endcase
  1419.  
  1420. *--- Analizo las unidades
  1421.     Do Case
  1422.     Case lnUnidades = 1
  1423.         lcCadena = Iif(lnTerna = 1 And tnFlag = 0, 'UNO ', 'UN ')
  1424.     Case lnUnidades = 2
  1425.         lcCadena = 'DOS '
  1426.     Case lnUnidades = 3
  1427.         lcCadena = 'TRES '
  1428.     Case lnUnidades = 4
  1429.         lcCadena = 'CUATRO '
  1430.     Case lnUnidades = 5
  1431.         lcCadena = 'CINCO '
  1432.     Case lnUnidades = 6
  1433.         lcCadena = 'SEIS '
  1434.     Case lnUnidades = 7
  1435.         lcCadena = 'SIETE '
  1436.     Case lnUnidades = 8
  1437.         lcCadena = 'OCHO '
  1438.     Case lnUnidades = 9
  1439.         lcCadena = 'NUEVE '
  1440.     Endcase
  1441.  
  1442. *--- Analizo las decenas
  1443.     Do Case
  1444.     Case lnDecenas = 1
  1445.         Do Case
  1446.         Case lnUnidades = 0
  1447.             lcCadena = 'DIEZ '
  1448.         Case lnUnidades = 1
  1449.             lcCadena = 'ONCE '
  1450.         Case lnUnidades = 2
  1451.             lcCadena = 'DOCE '
  1452.         Case lnUnidades = 3
  1453.             lcCadena = 'TRECE '
  1454.         Case lnUnidades = 4
  1455.             lcCadena = 'CATORCE '
  1456.         Case lnUnidades = 5
  1457.             lcCadena = 'QUINCE '
  1458.         Other
  1459.             lcCadena = 'DIECI' + lcCadena
  1460.         Endcase
  1461.     Case lnDecenas = 2
  1462.         lcCadena = Iif(lnUnidades = 0, 'VEINTE ', 'VEINTI') + lcCadena
  1463.     Case lnDecenas = 3
  1464.         lcCadena = 'TREINTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  1465.     Case lnDecenas = 4
  1466.         lcCadena = 'CUARENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  1467.     Case lnDecenas = 5
  1468.         lcCadena = 'CINCUENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  1469.     Case lnDecenas = 6
  1470.         lcCadena = 'SESENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  1471.     Case lnDecenas = 7
  1472.         lcCadena = 'SETENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  1473.     Case lnDecenas = 8
  1474.         lcCadena = 'OCHENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  1475.     Case lnDecenas = 9
  1476.         lcCadena = 'NOVENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  1477.     Endcase
  1478.  
  1479. *--- Analizo las centenas
  1480.     Do Case
  1481.     Case lnCentenas = 1
  1482.         lcCadena = Iif(lnUnidades = 0 And lnDecenas = 0, ;
  1483.             'CIEN ', 'CIENTO ') + lcCadena
  1484.     Case lnCentenas = 2
  1485.         lcCadena = 'DOSCIENTOS ' + lcCadena
  1486.     Case lnCentenas = 3
  1487.         lcCadena = 'TRESCIENTOS ' + lcCadena
  1488.     Case lnCentenas = 4
  1489.         lcCadena = 'CUATROCIENTOS ' + lcCadena
  1490.     Case lnCentenas = 5
  1491.         lcCadena = 'QUINIENTOS ' + lcCadena
  1492.     Case lnCentenas = 6
  1493.         lcCadena = 'SEISCIENTOS ' + lcCadena
  1494.     Case lnCentenas = 7
  1495.         lcCadena = 'SETECIENTOS ' + lcCadena
  1496.     Case lnCentenas = 8
  1497.         lcCadena = 'OCHOCIENTOS ' + lcCadena
  1498.     Case lnCentenas = 9
  1499.         lcCadena = 'NOVECIENTOS ' + lcCadena
  1500.     Endcase
  1501.  
  1502. *--- Armo el retorno terna a terna
  1503.     lcRetorno = lcCadena + lcMiles + lcRetorno
  1504.     lnTerna = lnTerna + 1
  1505. Enddo
  1506. If lnTerna = 1
  1507.     lcRetorno = 'CERO '
  1508. Endif
  1509. Return lcRetorno
  1510. Endfu
  1511. *--------------------------------------------------------------------------
  1512. * FUNCTION N2L(tnNro, tnFlag)
  1513. *--------------------------------------------------------------------------
  1514. * Devuelve un número entero en letras
  1515. * Usada por Let2Num (deben estar ambas)
  1516. * USO: ? N2L(32) -> TREINTA Y DOS
  1517. * RETORNA: Caracter
  1518. * AUTOR: LMG
  1519. *--------------------------------------------------------------------------
  1520. Function N2L(tnNro, tnFlag)
  1521. If Empty(tnFlag)
  1522.     tnFlag = 0
  1523. Endif
  1524. Local lnEntero, lcRetorno, lnTerna, lcMiles, ;
  1525.     lcCadena, lnUnidades, lnDecenas, lnCentenas
  1526. lnEntero = Int(tnNro)
  1527. lcRetorno = ''
  1528. lnTerna = 1
  1529. Do While lnEntero > 0
  1530.     lcCadena = ''
  1531.     lnUnidades = Mod(lnEntero, 10)
  1532.     lnEntero = Int(lnEntero / 10)
  1533.     lnDecenas = Mod(lnEntero, 10)
  1534.     lnEntero = Int(lnEntero / 10)
  1535.     lnCentenas = Mod(lnEntero, 10)
  1536.     lnEntero = Int(lnEntero / 10)
  1537.  
  1538. *--- Analizo la terna
  1539.     Do Case
  1540.     Case lnTerna = 1
  1541.         lcMiles = ''
  1542.     Case lnTerna = 2 And (lnUnidades + lnDecenas + lnCentenas # 0)
  1543.         lcMiles = 'MIL '
  1544.     Case lnTerna = 3 And (lnUnidades + lnDecenas + lnCentenas # 0)
  1545.         lcMiles = Iif(lnUnidades = 1 And lnDecenas = 0 And ;
  1546.             lnCentenas = 0, 'MILLON ', 'MILLONES ')
  1547.     Case lnTerna = 4 And (lnUnidades + lnDecenas + lnCentenas # 0)
  1548.         lcMiles = 'MIL MILLONES '
  1549.     Case lnTerna = 5 And (lnUnidades + lnDecenas + lnCentenas # 0)
  1550.         lcMiles = Iif(lnUnidades = 1 And lnDecenas = 0 And ;
  1551.             lnCentenas = 0, 'BILLON ', 'BILLONES ')
  1552.     Case lnTerna > 5
  1553.         lcRetorno = ' ERROR: NUMERO DEMASIADO GRANDE '
  1554.         Exit
  1555.     Endcase
  1556.  
  1557. *--- Analizo las unidades
  1558.     Do Case
  1559.     Case lnUnidades = 1
  1560.         lcCadena = Iif(lnTerna = 1 And tnFlag = 0, 'UNO ', 'UN ')
  1561.     Case lnUnidades = 2
  1562.         lcCadena = 'DOS '
  1563.     Case lnUnidades = 3
  1564.         lcCadena = 'TRES '
  1565.     Case lnUnidades = 4
  1566.         lcCadena = 'CUATRO '
  1567.     Case lnUnidades = 5
  1568.         lcCadena = 'CINCO '
  1569.     Case lnUnidades = 6
  1570.         lcCadena = 'SEIS '
  1571.     Case lnUnidades = 7
  1572.         lcCadena = 'SIETE '
  1573.     Case lnUnidades = 8
  1574.         lcCadena = 'OCHO '
  1575.     Case lnUnidades = 9
  1576.         lcCadena = 'NUEVE '
  1577.     Endcase
  1578.  
  1579. *--- Analizo las decenas
  1580.     Do Case
  1581.     Case lnDecenas = 1
  1582.         Do Case
  1583.         Case lnUnidades = 0
  1584.             lcCadena = 'DIEZ '
  1585.         Case lnUnidades = 1
  1586.             lcCadena = 'ONCE '
  1587.         Case lnUnidades = 2
  1588.             lcCadena = 'DOCE '
  1589.         Case lnUnidades = 3
  1590.             lcCadena = 'TRECE '
  1591.         Case lnUnidades = 4
  1592.             lcCadena = 'CATORCE '
  1593.         Case lnUnidades = 5
  1594.             lcCadena = 'QUINCE '
  1595.         Other
  1596.             lcCadena = 'DIECI' + lcCadena
  1597.         Endcase
  1598.     Case lnDecenas = 2
  1599.         lcCadena = Iif(lnUnidades = 0, 'VEINTE ', 'VEINTI') + lcCadena
  1600.     Case lnDecenas = 3
  1601.         lcCadena = 'TREINTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  1602.     Case lnDecenas = 4
  1603.         lcCadena = 'CUARENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  1604.     Case lnDecenas = 5
  1605.         lcCadena = 'CINCUENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  1606.     Case lnDecenas = 6
  1607.         lcCadena = 'SESENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  1608.     Case lnDecenas = 7
  1609.         lcCadena = 'SETENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  1610.     Case lnDecenas = 8
  1611.         lcCadena = 'OCHENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  1612.     Case lnDecenas = 9
  1613.         lcCadena = 'NOVENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  1614.     Endcase
  1615.  
  1616. *--- Analizo las centenas
  1617.     Do Case
  1618.     Case lnCentenas = 1
  1619.         lcCadena = Iif(lnUnidades = 0 And lnDecenas = 0, ;
  1620.             'CIEN ', 'CIENTO ') + lcCadena
  1621.     Case lnCentenas = 2
  1622.         lcCadena = 'DOSCIENTOS ' + lcCadena
  1623.     Case lnCentenas = 3
  1624.         lcCadena = 'TRESCIENTOS ' + lcCadena
  1625.     Case lnCentenas = 4
  1626.         lcCadena = 'CUATROCIENTOS ' + lcCadena
  1627.     Case lnCentenas = 5
  1628.         lcCadena = 'QUINIENTOS ' + lcCadena
  1629.     Case lnCentenas = 6
  1630.         lcCadena = 'SEISCIENTOS ' + lcCadena
  1631.     Case lnCentenas = 7
  1632.         lcCadena = 'SETECIENTOS ' + lcCadena
  1633.     Case lnCentenas = 8
  1634.         lcCadena = 'OCHOCIENTOS ' + lcCadena
  1635.     Case lnCentenas = 9
  1636.         lcCadena = 'NOVECIENTOS ' + lcCadena
  1637.     Endcase
  1638.  
  1639. *--- Armo el retorno terna a terna
  1640.     lcRetorno = lcCadena + lcMiles + lcRetorno
  1641.     lnTerna = lnTerna + 1
  1642. Enddo
  1643. If lnTerna = 1
  1644.     lcRetorno = 'CERO '
  1645. Endif
  1646. Return lcRetorno
  1647. Endfu
  1648. * FUNCTION N2L(tnNro, tnFlag)
  1649. *--------------------------------------------------------------------------
  1650. * Devuelve un número entero en letras
  1651. * Usada por Let2Num (deben estar ambas)
  1652. * USO: ? N2L(32) -> TREINTA Y DOS
  1653. * RETORNA: Caracter
  1654. * AUTOR: LMG
  1655. *--------------------------------------------------------------------------
  1656. Function N2L(tnNro, tnFlag)
  1657. If Empty(tnFlag)
  1658.     tnFlag = 0
  1659. Endif
  1660. Local lnEntero, lcRetorno, lnTerna, lcMiles, ;
  1661.     lcCadena, lnUnidades, lnDecenas, lnCentenas
  1662. lnEntero = Int(tnNro)
  1663. lcRetorno = ''
  1664. lnTerna = 1
  1665. Do While lnEntero > 0
  1666.     lcCadena = ''
  1667.     lnUnidades = Mod(lnEntero, 10)
  1668.     lnEntero = Int(lnEntero / 10)
  1669.     lnDecenas = Mod(lnEntero, 10)
  1670.     lnEntero = Int(lnEntero / 10)
  1671.     lnCentenas = Mod(lnEntero, 10)
  1672.     lnEntero = Int(lnEntero / 10)
  1673.  
  1674. *--- Analizo la terna
  1675.     Do Case
  1676.     Case lnTerna = 1
  1677.         lcMiles = ''
  1678.     Case lnTerna = 2 And (lnUnidades + lnDecenas + lnCentenas # 0)
  1679.         lcMiles = 'MIL '
  1680.     Case lnTerna = 3 And (lnUnidades + lnDecenas + lnCentenas # 0)
  1681.         lcMiles = Iif(lnUnidades = 1 And lnDecenas = 0 And ;
  1682.             lnCentenas = 0, 'MILLON ', 'MILLONES ')
  1683.     Case lnTerna = 4 And (lnUnidades + lnDecenas + lnCentenas # 0)
  1684.         lcMiles = 'MIL MILLONES '
  1685.     Case lnTerna = 5 And (lnUnidades + lnDecenas + lnCentenas # 0)
  1686.         lcMiles = Iif(lnUnidades = 1 And lnDecenas = 0 And ;
  1687.             lnCentenas = 0, 'BILLON ', 'BILLONES ')
  1688.     Case lnTerna > 5
  1689.         lcRetorno = ' ERROR: NUMERO DEMASIADO GRANDE '
  1690.         Exit
  1691.     Endcase
  1692.  
  1693. *--- Analizo las unidades
  1694.     Do Case
  1695.     Case lnUnidades = 1
  1696.         lcCadena = Iif(lnTerna = 1 And tnFlag = 0, 'UNO ', 'UN ')
  1697.     Case lnUnidades = 2
  1698.         lcCadena = 'DOS '
  1699.     Case lnUnidades = 3
  1700.         lcCadena = 'TRES '
  1701.     Case lnUnidades = 4
  1702.         lcCadena = 'CUATRO '
  1703.     Case lnUnidades = 5
  1704.         lcCadena = 'CINCO '
  1705.     Case lnUnidades = 6
  1706.         lcCadena = 'SEIS '
  1707.     Case lnUnidades = 7
  1708.         lcCadena = 'SIETE '
  1709.     Case lnUnidades = 8
  1710.         lcCadena = 'OCHO '
  1711.     Case lnUnidades = 9
  1712.         lcCadena = 'NUEVE '
  1713.     Endcase
  1714.  
  1715. *--- Analizo las decenas
  1716.     Do Case
  1717.     Case lnDecenas = 1
  1718.         Do Case
  1719.         Case lnUnidades = 0
  1720.             lcCadena = 'DIEZ '
  1721.         Case lnUnidades = 1
  1722.             lcCadena = 'ONCE '
  1723.         Case lnUnidades = 2
  1724.             lcCadena = 'DOCE '
  1725.         Case lnUnidades = 3
  1726.             lcCadena = 'TRECE '
  1727.         Case lnUnidades = 4
  1728.             lcCadena = 'CATORCE '
  1729.         Case lnUnidades = 5
  1730.             lcCadena = 'QUINCE '
  1731.         Other
  1732.             lcCadena = 'DIECI' + lcCadena
  1733.         Endcase
  1734.     Case lnDecenas = 2
  1735.         lcCadena = Iif(lnUnidades = 0, 'VEINTE ', 'VEINTI') + lcCadena
  1736.     Case lnDecenas = 3
  1737.         lcCadena = 'TREINTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  1738.     Case lnDecenas = 4
  1739.         lcCadena = 'CUARENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  1740.     Case lnDecenas = 5
  1741.         lcCadena = 'CINCUENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  1742.     Case lnDecenas = 6
  1743.         lcCadena = 'SESENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  1744.     Case lnDecenas = 7
  1745.         lcCadena = 'SETENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  1746.     Case lnDecenas = 8
  1747.         lcCadena = 'OCHENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  1748.     Case lnDecenas = 9
  1749.         lcCadena = 'NOVENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  1750.     Endcase
  1751.  
  1752. *--- Analizo las centenas
  1753.     Do Case
  1754.     Case lnCentenas = 1
  1755.         lcCadena = Iif(lnUnidades = 0 And lnDecenas = 0, ;
  1756.             'CIEN ', 'CIENTO ') + lcCadena
  1757.     Case lnCentenas = 2
  1758.         lcCadena = 'DOSCIENTOS ' + lcCadena
  1759.     Case lnCentenas = 3
  1760.         lcCadena = 'TRESCIENTOS ' + lcCadena
  1761.     Case lnCentenas = 4
  1762.         lcCadena = 'CUATROCIENTOS ' + lcCadena
  1763.     Case lnCentenas = 5
  1764.         lcCadena = 'QUINIENTOS ' + lcCadena
  1765.     Case lnCentenas = 6
  1766.         lcCadena = 'SEISCIENTOS ' + lcCadena
  1767.     Case lnCentenas = 7
  1768.         lcCadena = 'SETECIENTOS ' + lcCadena
  1769.     Case lnCentenas = 8
  1770.         lcCadena = 'OCHOCIENTOS ' + lcCadena
  1771.     Case lnCentenas = 9
  1772.         lcCadena = 'NOVECIENTOS ' + lcCadena
  1773.     Endcase
  1774.  
  1775. *--- Armo el retorno terna a terna
  1776.     lcRetorno = lcCadena + lcMiles + lcRetorno
  1777.     lnTerna = lnTerna + 1
  1778. Enddo
  1779. If lnTerna = 1
  1780.     lcRetorno = 'CERO '
  1781. Endif
  1782. Return lcRetorno
  1783. Endfu
  1784. *--------------------------------------------------------------------------
  1785. * Devuelve un número entero en letras
  1786. * Usada por Let2Num (deben estar ambas)
  1787. * USO: ? N2L(32) -> TREINTA Y DOS
  1788. * RETORNA: Caracter
  1789. * AUTOR: LMG
  1790. *--------------------------------------------------------------------------
  1791. Function N2L(tnNro, tnFlag)
  1792. If Empty(tnFlag)
  1793.     tnFlag = 0
  1794. Endif
  1795. Local lnEntero, lcRetorno, lnTerna, lcMiles, ;
  1796.     lcCadena, lnUnidades, lnDecenas, lnCentenas
  1797. lnEntero = Int(tnNro)
  1798. lcRetorno = ''
  1799. lnTerna = 1
  1800. Do While lnEntero > 0
  1801.     lcCadena = ''
  1802.     lnUnidades = Mod(lnEntero, 10)
  1803.     lnEntero = Int(lnEntero / 10)
  1804.     lnDecenas = Mod(lnEntero, 10)
  1805.     lnEntero = Int(lnEntero / 10)
  1806.     lnCentenas = Mod(lnEntero, 10)
  1807.     lnEntero = Int(lnEntero / 10)
  1808.  
  1809. *--- Analizo la terna
  1810.     Do Case
  1811.     Case lnTerna = 1
  1812.         lcMiles = ''
  1813.     Case lnTerna = 2 And (lnUnidades + lnDecenas + lnCentenas # 0)
  1814.         lcMiles = 'MIL '
  1815.     Case lnTerna = 3 And (lnUnidades + lnDecenas + lnCentenas # 0)
  1816.         lcMiles = Iif(lnUnidades = 1 And lnDecenas = 0 And ;
  1817.             lnCentenas = 0, 'MILLON ', 'MILLONES ')
  1818.     Case lnTerna = 4 And (lnUnidades + lnDecenas + lnCentenas # 0)
  1819.         lcMiles = 'MIL MILLONES '
  1820.     Case lnTerna = 5 And (lnUnidades + lnDecenas + lnCentenas # 0)
  1821.         lcMiles = Iif(lnUnidades = 1 And lnDecenas = 0 And ;
  1822.             lnCentenas = 0, 'BILLON ', 'BILLONES ')
  1823.     Case lnTerna > 5
  1824.         lcRetorno = ' ERROR: NUMERO DEMASIADO GRANDE '
  1825.         Exit
  1826.     Endcase
  1827.  
  1828. *--- Analizo las unidades
  1829.     Do Case
  1830.     Case lnUnidades = 1
  1831.         lcCadena = Iif(lnTerna = 1 And tnFlag = 0, 'UNO ', 'UN ')
  1832.     Case lnUnidades = 2
  1833.         lcCadena = 'DOS '
  1834.     Case lnUnidades = 3
  1835.         lcCadena = 'TRES '
  1836.     Case lnUnidades = 4
  1837.         lcCadena = 'CUATRO '
  1838.     Case lnUnidades = 5
  1839.         lcCadena = 'CINCO '
  1840.     Case lnUnidades = 6
  1841.         lcCadena = 'SEIS '
  1842.     Case lnUnidades = 7
  1843.         lcCadena = 'SIETE '
  1844.     Case lnUnidades = 8
  1845.         lcCadena = 'OCHO '
  1846.     Case lnUnidades = 9
  1847.         lcCadena = 'NUEVE '
  1848.     Endcase
  1849.  
  1850. *--- Analizo las decenas
  1851.     Do Case
  1852.     Case lnDecenas = 1
  1853.         Do Case
  1854.         Case lnUnidades = 0
  1855.             lcCadena = 'DIEZ '
  1856.         Case lnUnidades = 1
  1857.             lcCadena = 'ONCE '
  1858.         Case lnUnidades = 2
  1859.             lcCadena = 'DOCE '
  1860.         Case lnUnidades = 3
  1861.             lcCadena = 'TRECE '
  1862.         Case lnUnidades = 4
  1863.             lcCadena = 'CATORCE '
  1864.         Case lnUnidades = 5
  1865.             lcCadena = 'QUINCE '
  1866.         Other
  1867.             lcCadena = 'DIECI' + lcCadena
  1868.         Endcase
  1869.     Case lnDecenas = 2
  1870.         lcCadena = Iif(lnUnidades = 0, 'VEINTE ', 'VEINTI') + lcCadena
  1871.     Case lnDecenas = 3
  1872.         lcCadena = 'TREINTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  1873.     Case lnDecenas = 4
  1874.         lcCadena = 'CUARENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  1875.     Case lnDecenas = 5
  1876.         lcCadena = 'CINCUENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  1877.     Case lnDecenas = 6
  1878.         lcCadena = 'SESENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  1879.     Case lnDecenas = 7
  1880.         lcCadena = 'SETENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  1881.     Case lnDecenas = 8
  1882.         lcCadena = 'OCHENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  1883.     Case lnDecenas = 9
  1884.         lcCadena = 'NOVENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  1885.     Endcase
  1886.  
  1887. *--- Analizo las centenas
  1888.     Do Case
  1889.     Case lnCentenas = 1
  1890.         lcCadena = Iif(lnUnidades = 0 And lnDecenas = 0, ;
  1891.             'CIEN ', 'CIENTO ') + lcCadena
  1892.     Case lnCentenas = 2
  1893.         lcCadena = 'DOSCIENTOS ' + lcCadena
  1894.     Case lnCentenas = 3
  1895.         lcCadena = 'TRESCIENTOS ' + lcCadena
  1896.     Case lnCentenas = 4
  1897.         lcCadena = 'CUATROCIENTOS ' + lcCadena
  1898.     Case lnCentenas = 5
  1899.         lcCadena = 'QUINIENTOS ' + lcCadena
  1900.     Case lnCentenas = 6
  1901.         lcCadena = 'SEISCIENTOS ' + lcCadena
  1902.     Case lnCentenas = 7
  1903.         lcCadena = 'SETECIENTOS ' + lcCadena
  1904.     Case lnCentenas = 8
  1905.         lcCadena = 'OCHOCIENTOS ' + lcCadena
  1906.     Case lnCentenas = 9
  1907.         lcCadena = 'NOVECIENTOS ' + lcCadena
  1908.     Endcase
  1909.  
  1910. *--- Armo el retorno terna a terna
  1911.     lcRetorno = lcCadena + lcMiles + lcRetorno
  1912.     lnTerna = lnTerna + 1
  1913. Enddo
  1914. If lnTerna = 1
  1915.     lcRetorno = 'CERO '
  1916. Endif
  1917. Return lcRetorno
  1918. Endfu
  1919. * Devuelve un número entero en letras
  1920. * Usada por Let2Num (deben estar ambas)
  1921. * USO: ? N2L(32) -> TREINTA Y DOS
  1922. * RETORNA: Caracter
  1923. * AUTOR: LMG
  1924. *--------------------------------------------------------------------------
  1925. Function N2L(tnNro, tnFlag)
  1926. If Empty(tnFlag)
  1927.     tnFlag = 0
  1928. Endif
  1929. Local lnEntero, lcRetorno, lnTerna, lcMiles, ;
  1930.     lcCadena, lnUnidades, lnDecenas, lnCentenas
  1931. lnEntero = Int(tnNro)
  1932. lcRetorno = ''
  1933. lnTerna = 1
  1934. Do While lnEntero > 0
  1935.     lcCadena = ''
  1936.     lnUnidades = Mod(lnEntero, 10)
  1937.     lnEntero = Int(lnEntero / 10)
  1938.     lnDecenas = Mod(lnEntero, 10)
  1939.     lnEntero = Int(lnEntero / 10)
  1940.     lnCentenas = Mod(lnEntero, 10)
  1941.     lnEntero = Int(lnEntero / 10)
  1942.  
  1943. *--- Analizo la terna
  1944.     Do Case
  1945.     Case lnTerna = 1
  1946.         lcMiles = ''
  1947.     Case lnTerna = 2 And (lnUnidades + lnDecenas + lnCentenas # 0)
  1948.         lcMiles = 'MIL '
  1949.     Case lnTerna = 3 And (lnUnidades + lnDecenas + lnCentenas # 0)
  1950.         lcMiles = Iif(lnUnidades = 1 And lnDecenas = 0 And ;
  1951.             lnCentenas = 0, 'MILLON ', 'MILLONES ')
  1952.     Case lnTerna = 4 And (lnUnidades + lnDecenas + lnCentenas # 0)
  1953.         lcMiles = 'MIL MILLONES '
  1954.     Case lnTerna = 5 And (lnUnidades + lnDecenas + lnCentenas # 0)
  1955.         lcMiles = Iif(lnUnidades = 1 And lnDecenas = 0 And ;
  1956.             lnCentenas = 0, 'BILLON ', 'BILLONES ')
  1957.     Case lnTerna > 5
  1958.         lcRetorno = ' ERROR: NUMERO DEMASIADO GRANDE '
  1959.         Exit
  1960.     Endcase
  1961.  
  1962. *--- Analizo las unidades
  1963.     Do Case
  1964.     Case lnUnidades = 1
  1965.         lcCadena = Iif(lnTerna = 1 And tnFlag = 0, 'UNO ', 'UN ')
  1966.     Case lnUnidades = 2
  1967.         lcCadena = 'DOS '
  1968.     Case lnUnidades = 3
  1969.         lcCadena = 'TRES '
  1970.     Case lnUnidades = 4
  1971.         lcCadena = 'CUATRO '
  1972.     Case lnUnidades = 5
  1973.         lcCadena = 'CINCO '
  1974.     Case lnUnidades = 6
  1975.         lcCadena = 'SEIS '
  1976.     Case lnUnidades = 7
  1977.         lcCadena = 'SIETE '
  1978.     Case lnUnidades = 8
  1979.         lcCadena = 'OCHO '
  1980.     Case lnUnidades = 9
  1981.         lcCadena = 'NUEVE '
  1982.     Endcase
  1983.  
  1984. *--- Analizo las decenas
  1985.     Do Case
  1986.     Case lnDecenas = 1
  1987.         Do Case
  1988.         Case lnUnidades = 0
  1989.             lcCadena = 'DIEZ '
  1990.         Case lnUnidades = 1
  1991.             lcCadena = 'ONCE '
  1992.         Case lnUnidades = 2
  1993.             lcCadena = 'DOCE '
  1994.         Case lnUnidades = 3
  1995.             lcCadena = 'TRECE '
  1996.         Case lnUnidades = 4
  1997.             lcCadena = 'CATORCE '
  1998.         Case lnUnidades = 5
  1999.             lcCadena = 'QUINCE '
  2000.         Other
  2001.             lcCadena = 'DIECI' + lcCadena
  2002.         Endcase
  2003.     Case lnDecenas = 2
  2004.         lcCadena = Iif(lnUnidades = 0, 'VEINTE ', 'VEINTI') + lcCadena
  2005.     Case lnDecenas = 3
  2006.         lcCadena = 'TREINTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  2007.     Case lnDecenas = 4
  2008.         lcCadena = 'CUARENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  2009.     Case lnDecenas = 5
  2010.         lcCadena = 'CINCUENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  2011.     Case lnDecenas = 6
  2012.         lcCadena = 'SESENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  2013.     Case lnDecenas = 7
  2014.         lcCadena = 'SETENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  2015.     Case lnDecenas = 8
  2016.         lcCadena = 'OCHENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  2017.     Case lnDecenas = 9
  2018.         lcCadena = 'NOVENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  2019.     Endcase
  2020.  
  2021. *--- Analizo las centenas
  2022.     Do Case
  2023.     Case lnCentenas = 1
  2024.         lcCadena = Iif(lnUnidades = 0 And lnDecenas = 0, ;
  2025.             'CIEN ', 'CIENTO ') + lcCadena
  2026.     Case lnCentenas = 2
  2027.         lcCadena = 'DOSCIENTOS ' + lcCadena
  2028.     Case lnCentenas = 3
  2029.         lcCadena = 'TRESCIENTOS ' + lcCadena
  2030.     Case lnCentenas = 4
  2031.         lcCadena = 'CUATROCIENTOS ' + lcCadena
  2032.     Case lnCentenas = 5
  2033.         lcCadena = 'QUINIENTOS ' + lcCadena
  2034.     Case lnCentenas = 6
  2035.         lcCadena = 'SEISCIENTOS ' + lcCadena
  2036.     Case lnCentenas = 7
  2037.         lcCadena = 'SETECIENTOS ' + lcCadena
  2038.     Case lnCentenas = 8
  2039.         lcCadena = 'OCHOCIENTOS ' + lcCadena
  2040.     Case lnCentenas = 9
  2041.         lcCadena = 'NOVECIENTOS ' + lcCadena
  2042.     Endcase
  2043.  
  2044. *--- Armo el retorno terna a terna
  2045.     lcRetorno = lcCadena + lcMiles + lcRetorno
  2046.     lnTerna = lnTerna + 1
  2047. Enddo
  2048. If lnTerna = 1
  2049.     lcRetorno = 'CERO '
  2050. Endif
  2051. Return lcRetorno
  2052. Endfu
  2053. * Usada por Let2Num (deben estar ambas)
  2054. * USO: ? N2L(32) -> TREINTA Y DOS
  2055. * RETORNA: Caracter
  2056. * AUTOR: LMG
  2057. *--------------------------------------------------------------------------
  2058. Function N2L(tnNro, tnFlag)
  2059. If Empty(tnFlag)
  2060.     tnFlag = 0
  2061. Endif
  2062. Local lnEntero, lcRetorno, lnTerna, lcMiles, ;
  2063.     lcCadena, lnUnidades, lnDecenas, lnCentenas
  2064. lnEntero = Int(tnNro)
  2065. lcRetorno = ''
  2066. lnTerna = 1
  2067. Do While lnEntero > 0
  2068.     lcCadena = ''
  2069.     lnUnidades = Mod(lnEntero, 10)
  2070.     lnEntero = Int(lnEntero / 10)
  2071.     lnDecenas = Mod(lnEntero, 10)
  2072.     lnEntero = Int(lnEntero / 10)
  2073.     lnCentenas = Mod(lnEntero, 10)
  2074.     lnEntero = Int(lnEntero / 10)
  2075.  
  2076. *--- Analizo la terna
  2077.     Do Case
  2078.     Case lnTerna = 1
  2079.         lcMiles = ''
  2080.     Case lnTerna = 2 And (lnUnidades + lnDecenas + lnCentenas # 0)
  2081.         lcMiles = 'MIL '
  2082.     Case lnTerna = 3 And (lnUnidades + lnDecenas + lnCentenas # 0)
  2083.         lcMiles = Iif(lnUnidades = 1 And lnDecenas = 0 And ;
  2084.             lnCentenas = 0, 'MILLON ', 'MILLONES ')
  2085.     Case lnTerna = 4 And (lnUnidades + lnDecenas + lnCentenas # 0)
  2086.         lcMiles = 'MIL MILLONES '
  2087.     Case lnTerna = 5 And (lnUnidades + lnDecenas + lnCentenas # 0)
  2088.         lcMiles = Iif(lnUnidades = 1 And lnDecenas = 0 And ;
  2089.             lnCentenas = 0, 'BILLON ', 'BILLONES ')
  2090.     Case lnTerna > 5
  2091.         lcRetorno = ' ERROR: NUMERO DEMASIADO GRANDE '
  2092.         Exit
  2093.     Endcase
  2094.  
  2095. *--- Analizo las unidades
  2096.     Do Case
  2097.     Case lnUnidades = 1
  2098.         lcCadena = Iif(lnTerna = 1 And tnFlag = 0, 'UNO ', 'UN ')
  2099.     Case lnUnidades = 2
  2100.         lcCadena = 'DOS '
  2101.     Case lnUnidades = 3
  2102.         lcCadena = 'TRES '
  2103.     Case lnUnidades = 4
  2104.         lcCadena = 'CUATRO '
  2105.     Case lnUnidades = 5
  2106.         lcCadena = 'CINCO '
  2107.     Case lnUnidades = 6
  2108.         lcCadena = 'SEIS '
  2109.     Case lnUnidades = 7
  2110.         lcCadena = 'SIETE '
  2111.     Case lnUnidades = 8
  2112.         lcCadena = 'OCHO '
  2113.     Case lnUnidades = 9
  2114.         lcCadena = 'NUEVE '
  2115.     Endcase
  2116.  
  2117. *--- Analizo las decenas
  2118.     Do Case
  2119.     Case lnDecenas = 1
  2120.         Do Case
  2121.         Case lnUnidades = 0
  2122.             lcCadena = 'DIEZ '
  2123.         Case lnUnidades = 1
  2124.             lcCadena = 'ONCE '
  2125.         Case lnUnidades = 2
  2126.             lcCadena = 'DOCE '
  2127.         Case lnUnidades = 3
  2128.             lcCadena = 'TRECE '
  2129.         Case lnUnidades = 4
  2130.             lcCadena = 'CATORCE '
  2131.         Case lnUnidades = 5
  2132.             lcCadena = 'QUINCE '
  2133.         Other
  2134.             lcCadena = 'DIECI' + lcCadena
  2135.         Endcase
  2136.     Case lnDecenas = 2
  2137.         lcCadena = Iif(lnUnidades = 0, 'VEINTE ', 'VEINTI') + lcCadena
  2138.     Case lnDecenas = 3
  2139.         lcCadena = 'TREINTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  2140.     Case lnDecenas = 4
  2141.         lcCadena = 'CUARENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  2142.     Case lnDecenas = 5
  2143.         lcCadena = 'CINCUENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  2144.     Case lnDecenas = 6
  2145.         lcCadena = 'SESENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  2146.     Case lnDecenas = 7
  2147.         lcCadena = 'SETENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  2148.     Case lnDecenas = 8
  2149.         lcCadena = 'OCHENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  2150.     Case lnDecenas = 9
  2151.         lcCadena = 'NOVENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  2152.     Endcase
  2153.  
  2154. *--- Analizo las centenas
  2155.     Do Case
  2156.     Case lnCentenas = 1
  2157.         lcCadena = Iif(lnUnidades = 0 And lnDecenas = 0, ;
  2158.             'CIEN ', 'CIENTO ') + lcCadena
  2159.     Case lnCentenas = 2
  2160.         lcCadena = 'DOSCIENTOS ' + lcCadena
  2161.     Case lnCentenas = 3
  2162.         lcCadena = 'TRESCIENTOS ' + lcCadena
  2163.     Case lnCentenas = 4
  2164.         lcCadena = 'CUATROCIENTOS ' + lcCadena
  2165.     Case lnCentenas = 5
  2166.         lcCadena = 'QUINIENTOS ' + lcCadena
  2167.     Case lnCentenas = 6
  2168.         lcCadena = 'SEISCIENTOS ' + lcCadena
  2169.     Case lnCentenas = 7
  2170.         lcCadena = 'SETECIENTOS ' + lcCadena
  2171.     Case lnCentenas = 8
  2172.         lcCadena = 'OCHOCIENTOS ' + lcCadena
  2173.     Case lnCentenas = 9
  2174.         lcCadena = 'NOVECIENTOS ' + lcCadena
  2175.     Endcase
  2176.  
  2177. *--- Armo el retorno terna a terna
  2178.     lcRetorno = lcCadena + lcMiles + lcRetorno
  2179.     lnTerna = lnTerna + 1
  2180. Enddo
  2181. If lnTerna = 1
  2182.     lcRetorno = 'CERO '
  2183. Endif
  2184. Return lcRetorno
  2185. Endfu
  2186. * USO: ? N2L(32) -> TREINTA Y DOS
  2187. * RETORNA: Caracter
  2188. * AUTOR: LMG
  2189. *--------------------------------------------------------------------------
  2190. Function N2L(tnNro, tnFlag)
  2191. If Empty(tnFlag)
  2192.     tnFlag = 0
  2193. Endif
  2194. Local lnEntero, lcRetorno, lnTerna, lcMiles, ;
  2195.     lcCadena, lnUnidades, lnDecenas, lnCentenas
  2196. lnEntero = Int(tnNro)
  2197. lcRetorno = ''
  2198. lnTerna = 1
  2199. Do While lnEntero > 0
  2200.     lcCadena = ''
  2201.     lnUnidades = Mod(lnEntero, 10)
  2202.     lnEntero = Int(lnEntero / 10)
  2203.     lnDecenas = Mod(lnEntero, 10)
  2204.     lnEntero = Int(lnEntero / 10)
  2205.     lnCentenas = Mod(lnEntero, 10)
  2206.     lnEntero = Int(lnEntero / 10)
  2207.  
  2208. *--- Analizo la terna
  2209.     Do Case
  2210.     Case lnTerna = 1
  2211.         lcMiles = ''
  2212.     Case lnTerna = 2 And (lnUnidades + lnDecenas + lnCentenas # 0)
  2213.         lcMiles = 'MIL '
  2214.     Case lnTerna = 3 And (lnUnidades + lnDecenas + lnCentenas # 0)
  2215.         lcMiles = Iif(lnUnidades = 1 And lnDecenas = 0 And ;
  2216.             lnCentenas = 0, 'MILLON ', 'MILLONES ')
  2217.     Case lnTerna = 4 And (lnUnidades + lnDecenas + lnCentenas # 0)
  2218.         lcMiles = 'MIL MILLONES '
  2219.     Case lnTerna = 5 And (lnUnidades + lnDecenas + lnCentenas # 0)
  2220.         lcMiles = Iif(lnUnidades = 1 And lnDecenas = 0 And ;
  2221.             lnCentenas = 0, 'BILLON ', 'BILLONES ')
  2222.     Case lnTerna > 5
  2223.         lcRetorno = ' ERROR: NUMERO DEMASIADO GRANDE '
  2224.         Exit
  2225.     Endcase
  2226.  
  2227. *--- Analizo las unidades
  2228.     Do Case
  2229.     Case lnUnidades = 1
  2230.         lcCadena = Iif(lnTerna = 1 And tnFlag = 0, 'UNO ', 'UN ')
  2231.     Case lnUnidades = 2
  2232.         lcCadena = 'DOS '
  2233.     Case lnUnidades = 3
  2234.         lcCadena = 'TRES '
  2235.     Case lnUnidades = 4
  2236.         lcCadena = 'CUATRO '
  2237.     Case lnUnidades = 5
  2238.         lcCadena = 'CINCO '
  2239.     Case lnUnidades = 6
  2240.         lcCadena = 'SEIS '
  2241.     Case lnUnidades = 7
  2242.         lcCadena = 'SIETE '
  2243.     Case lnUnidades = 8
  2244.         lcCadena = 'OCHO '
  2245.     Case lnUnidades = 9
  2246.         lcCadena = 'NUEVE '
  2247.     Endcase
  2248.  
  2249. *--- Analizo las decenas
  2250.     Do Case
  2251.     Case lnDecenas = 1
  2252.         Do Case
  2253.         Case lnUnidades = 0
  2254.             lcCadena = 'DIEZ '
  2255.         Case lnUnidades = 1
  2256.             lcCadena = 'ONCE '
  2257.         Case lnUnidades = 2
  2258.             lcCadena = 'DOCE '
  2259.         Case lnUnidades = 3
  2260.             lcCadena = 'TRECE '
  2261.         Case lnUnidades = 4
  2262.             lcCadena = 'CATORCE '
  2263.         Case lnUnidades = 5
  2264.             lcCadena = 'QUINCE '
  2265.         Other
  2266.             lcCadena = 'DIECI' + lcCadena
  2267.         Endcase
  2268.     Case lnDecenas = 2
  2269.         lcCadena = Iif(lnUnidades = 0, 'VEINTE ', 'VEINTI') + lcCadena
  2270.     Case lnDecenas = 3
  2271.         lcCadena = 'TREINTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  2272.     Case lnDecenas = 4
  2273.         lcCadena = 'CUARENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  2274.     Case lnDecenas = 5
  2275.         lcCadena = 'CINCUENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  2276.     Case lnDecenas = 6
  2277.         lcCadena = 'SESENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  2278.     Case lnDecenas = 7
  2279.         lcCadena = 'SETENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  2280.     Case lnDecenas = 8
  2281.         lcCadena = 'OCHENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  2282.     Case lnDecenas = 9
  2283.         lcCadena = 'NOVENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  2284.     Endcase
  2285.  
  2286. *--- Analizo las centenas
  2287.     Do Case
  2288.     Case lnCentenas = 1
  2289.         lcCadena = Iif(lnUnidades = 0 And lnDecenas = 0, ;
  2290.             'CIEN ', 'CIENTO ') + lcCadena
  2291.     Case lnCentenas = 2
  2292.         lcCadena = 'DOSCIENTOS ' + lcCadena
  2293.     Case lnCentenas = 3
  2294.         lcCadena = 'TRESCIENTOS ' + lcCadena
  2295.     Case lnCentenas = 4
  2296.         lcCadena = 'CUATROCIENTOS ' + lcCadena
  2297.     Case lnCentenas = 5
  2298.         lcCadena = 'QUINIENTOS ' + lcCadena
  2299.     Case lnCentenas = 6
  2300.         lcCadena = 'SEISCIENTOS ' + lcCadena
  2301.     Case lnCentenas = 7
  2302.         lcCadena = 'SETECIENTOS ' + lcCadena
  2303.     Case lnCentenas = 8
  2304.         lcCadena = 'OCHOCIENTOS ' + lcCadena
  2305.     Case lnCentenas = 9
  2306.         lcCadena = 'NOVECIENTOS ' + lcCadena
  2307.     Endcase
  2308.  
  2309. *--- Armo el retorno terna a terna
  2310.     lcRetorno = lcCadena + lcMiles + lcRetorno
  2311.     lnTerna = lnTerna + 1
  2312. Enddo
  2313. If lnTerna = 1
  2314.     lcRetorno = 'CERO '
  2315. Endif
  2316. Return lcRetorno
  2317. Endfu
  2318. * RETORNA: Caracter
  2319. * AUTOR: LMG
  2320. *--------------------------------------------------------------------------
  2321. Function N2L(tnNro, tnFlag)
  2322. If Empty(tnFlag)
  2323.     tnFlag = 0
  2324. Endif
  2325. Local lnEntero, lcRetorno, lnTerna, lcMiles, ;
  2326.     lcCadena, lnUnidades, lnDecenas, lnCentenas
  2327. lnEntero = Int(tnNro)
  2328. lcRetorno = ''
  2329. lnTerna = 1
  2330. Do While lnEntero > 0
  2331.     lcCadena = ''
  2332.     lnUnidades = Mod(lnEntero, 10)
  2333.     lnEntero = Int(lnEntero / 10)
  2334.     lnDecenas = Mod(lnEntero, 10)
  2335.     lnEntero = Int(lnEntero / 10)
  2336.     lnCentenas = Mod(lnEntero, 10)
  2337.     lnEntero = Int(lnEntero / 10)
  2338.  
  2339. *--- Analizo la terna
  2340.     Do Case
  2341.     Case lnTerna = 1
  2342.         lcMiles = ''
  2343.     Case lnTerna = 2 And (lnUnidades + lnDecenas + lnCentenas # 0)
  2344.         lcMiles = 'MIL '
  2345.     Case lnTerna = 3 And (lnUnidades + lnDecenas + lnCentenas # 0)
  2346.         lcMiles = Iif(lnUnidades = 1 And lnDecenas = 0 And ;
  2347.             lnCentenas = 0, 'MILLON ', 'MILLONES ')
  2348.     Case lnTerna = 4 And (lnUnidades + lnDecenas + lnCentenas # 0)
  2349.         lcMiles = 'MIL MILLONES '
  2350.     Case lnTerna = 5 And (lnUnidades + lnDecenas + lnCentenas # 0)
  2351.         lcMiles = Iif(lnUnidades = 1 And lnDecenas = 0 And ;
  2352.             lnCentenas = 0, 'BILLON ', 'BILLONES ')
  2353.     Case lnTerna > 5
  2354.         lcRetorno = ' ERROR: NUMERO DEMASIADO GRANDE '
  2355.         Exit
  2356.     Endcase
  2357.  
  2358. *--- Analizo las unidades
  2359.     Do Case
  2360.     Case lnUnidades = 1
  2361.         lcCadena = Iif(lnTerna = 1 And tnFlag = 0, 'UNO ', 'UN ')
  2362.     Case lnUnidades = 2
  2363.         lcCadena = 'DOS '
  2364.     Case lnUnidades = 3
  2365.         lcCadena = 'TRES '
  2366.     Case lnUnidades = 4
  2367.         lcCadena = 'CUATRO '
  2368.     Case lnUnidades = 5
  2369.         lcCadena = 'CINCO '
  2370.     Case lnUnidades = 6
  2371.         lcCadena = 'SEIS '
  2372.     Case lnUnidades = 7
  2373.         lcCadena = 'SIETE '
  2374.     Case lnUnidades = 8
  2375.         lcCadena = 'OCHO '
  2376.     Case lnUnidades = 9
  2377.         lcCadena = 'NUEVE '
  2378.     Endcase
  2379.  
  2380. *--- Analizo las decenas
  2381.     Do Case
  2382.     Case lnDecenas = 1
  2383.         Do Case
  2384.         Case lnUnidades = 0
  2385.             lcCadena = 'DIEZ '
  2386.         Case lnUnidades = 1
  2387.             lcCadena = 'ONCE '
  2388.         Case lnUnidades = 2
  2389.             lcCadena = 'DOCE '
  2390.         Case lnUnidades = 3
  2391.             lcCadena = 'TRECE '
  2392.         Case lnUnidades = 4
  2393.             lcCadena = 'CATORCE '
  2394.         Case lnUnidades = 5
  2395.             lcCadena = 'QUINCE '
  2396.         Other
  2397.             lcCadena = 'DIECI' + lcCadena
  2398.         Endcase
  2399.     Case lnDecenas = 2
  2400.         lcCadena = Iif(lnUnidades = 0, 'VEINTE ', 'VEINTI') + lcCadena
  2401.     Case lnDecenas = 3
  2402.         lcCadena = 'TREINTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  2403.     Case lnDecenas = 4
  2404.         lcCadena = 'CUARENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  2405.     Case lnDecenas = 5
  2406.         lcCadena = 'CINCUENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  2407.     Case lnDecenas = 6
  2408.         lcCadena = 'SESENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  2409.     Case lnDecenas = 7
  2410.         lcCadena = 'SETENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  2411.     Case lnDecenas = 8
  2412.         lcCadena = 'OCHENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  2413.     Case lnDecenas = 9
  2414.         lcCadena = 'NOVENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  2415.     Endcase
  2416.  
  2417. *--- Analizo las centenas
  2418.     Do Case
  2419.     Case lnCentenas = 1
  2420.         lcCadena = Iif(lnUnidades = 0 And lnDecenas = 0, ;
  2421.             'CIEN ', 'CIENTO ') + lcCadena
  2422.     Case lnCentenas = 2
  2423.         lcCadena = 'DOSCIENTOS ' + lcCadena
  2424.     Case lnCentenas = 3
  2425.         lcCadena = 'TRESCIENTOS ' + lcCadena
  2426.     Case lnCentenas = 4
  2427.         lcCadena = 'CUATROCIENTOS ' + lcCadena
  2428.     Case lnCentenas = 5
  2429.         lcCadena = 'QUINIENTOS ' + lcCadena
  2430.     Case lnCentenas = 6
  2431.         lcCadena = 'SEISCIENTOS ' + lcCadena
  2432.     Case lnCentenas = 7
  2433.         lcCadena = 'SETECIENTOS ' + lcCadena
  2434.     Case lnCentenas = 8
  2435.         lcCadena = 'OCHOCIENTOS ' + lcCadena
  2436.     Case lnCentenas = 9
  2437.         lcCadena = 'NOVECIENTOS ' + lcCadena
  2438.     Endcase
  2439.  
  2440. *--- Armo el retorno terna a terna
  2441.     lcRetorno = lcCadena + lcMiles + lcRetorno
  2442.     lnTerna = lnTerna + 1
  2443. Enddo
  2444. If lnTerna = 1
  2445.     lcRetorno = 'CERO '
  2446. Endif
  2447. Return lcRetorno
  2448. Endfu
  2449. * AUTOR: LMG
  2450. *--------------------------------------------------------------------------
  2451. Function N2L(tnNro, tnFlag)
  2452. If Empty(tnFlag)
  2453.     tnFlag = 0
  2454. Endif
  2455. Local lnEntero, lcRetorno, lnTerna, lcMiles, ;
  2456.     lcCadena, lnUnidades, lnDecenas, lnCentenas
  2457. lnEntero = Int(tnNro)
  2458. lcRetorno = ''
  2459. lnTerna = 1
  2460. Do While lnEntero > 0
  2461.     lcCadena = ''
  2462.     lnUnidades = Mod(lnEntero, 10)
  2463.     lnEntero = Int(lnEntero / 10)
  2464.     lnDecenas = Mod(lnEntero, 10)
  2465.     lnEntero = Int(lnEntero / 10)
  2466.     lnCentenas = Mod(lnEntero, 10)
  2467.     lnEntero = Int(lnEntero / 10)
  2468.  
  2469. *--- Analizo la terna
  2470.     Do Case
  2471.     Case lnTerna = 1
  2472.         lcMiles = ''
  2473.     Case lnTerna = 2 And (lnUnidades + lnDecenas + lnCentenas # 0)
  2474.         lcMiles = 'MIL '
  2475.     Case lnTerna = 3 And (lnUnidades + lnDecenas + lnCentenas # 0)
  2476.         lcMiles = Iif(lnUnidades = 1 And lnDecenas = 0 And ;
  2477.             lnCentenas = 0, 'MILLON ', 'MILLONES ')
  2478.     Case lnTerna = 4 And (lnUnidades + lnDecenas + lnCentenas # 0)
  2479.         lcMiles = 'MIL MILLONES '
  2480.     Case lnTerna = 5 And (lnUnidades + lnDecenas + lnCentenas # 0)
  2481.         lcMiles = Iif(lnUnidades = 1 And lnDecenas = 0 And ;
  2482.             lnCentenas = 0, 'BILLON ', 'BILLONES ')
  2483.     Case lnTerna > 5
  2484.         lcRetorno = ' ERROR: NUMERO DEMASIADO GRANDE '
  2485.         Exit
  2486.     Endcase
  2487.  
  2488. *--- Analizo las unidades
  2489.     Do Case
  2490.     Case lnUnidades = 1
  2491.         lcCadena = Iif(lnTerna = 1 And tnFlag = 0, 'UNO ', 'UN ')
  2492.     Case lnUnidades = 2
  2493.         lcCadena = 'DOS '
  2494.     Case lnUnidades = 3
  2495.         lcCadena = 'TRES '
  2496.     Case lnUnidades = 4
  2497.         lcCadena = 'CUATRO '
  2498.     Case lnUnidades = 5
  2499.         lcCadena = 'CINCO '
  2500.     Case lnUnidades = 6
  2501.         lcCadena = 'SEIS '
  2502.     Case lnUnidades = 7
  2503.         lcCadena = 'SIETE '
  2504.     Case lnUnidades = 8
  2505.         lcCadena = 'OCHO '
  2506.     Case lnUnidades = 9
  2507.         lcCadena = 'NUEVE '
  2508.     Endcase
  2509.  
  2510. *--- Analizo las decenas
  2511.     Do Case
  2512.     Case lnDecenas = 1
  2513.         Do Case
  2514.         Case lnUnidades = 0
  2515.             lcCadena = 'DIEZ '
  2516.         Case lnUnidades = 1
  2517.             lcCadena = 'ONCE '
  2518.         Case lnUnidades = 2
  2519.             lcCadena = 'DOCE '
  2520.         Case lnUnidades = 3
  2521.             lcCadena = 'TRECE '
  2522.         Case lnUnidades = 4
  2523.             lcCadena = 'CATORCE '
  2524.         Case lnUnidades = 5
  2525.             lcCadena = 'QUINCE '
  2526.         Other
  2527.             lcCadena = 'DIECI' + lcCadena
  2528.         Endcase
  2529.     Case lnDecenas = 2
  2530.         lcCadena = Iif(lnUnidades = 0, 'VEINTE ', 'VEINTI') + lcCadena
  2531.     Case lnDecenas = 3
  2532.         lcCadena = 'TREINTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  2533.     Case lnDecenas = 4
  2534.         lcCadena = 'CUARENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  2535.     Case lnDecenas = 5
  2536.         lcCadena = 'CINCUENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  2537.     Case lnDecenas = 6
  2538.         lcCadena = 'SESENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  2539.     Case lnDecenas = 7
  2540.         lcCadena = 'SETENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  2541.     Case lnDecenas = 8
  2542.         lcCadena = 'OCHENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  2543.     Case lnDecenas = 9
  2544.         lcCadena = 'NOVENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  2545.     Endcase
  2546.  
  2547. *--- Analizo las centenas
  2548.     Do Case
  2549.     Case lnCentenas = 1
  2550.         lcCadena = Iif(lnUnidades = 0 And lnDecenas = 0, ;
  2551.             'CIEN ', 'CIENTO ') + lcCadena
  2552.     Case lnCentenas = 2
  2553.         lcCadena = 'DOSCIENTOS ' + lcCadena
  2554.     Case lnCentenas = 3
  2555.         lcCadena = 'TRESCIENTOS ' + lcCadena
  2556.     Case lnCentenas = 4
  2557.         lcCadena = 'CUATROCIENTOS ' + lcCadena
  2558.     Case lnCentenas = 5
  2559.         lcCadena = 'QUINIENTOS ' + lcCadena
  2560.     Case lnCentenas = 6
  2561.         lcCadena = 'SEISCIENTOS ' + lcCadena
  2562.     Case lnCentenas = 7
  2563.         lcCadena = 'SETECIENTOS ' + lcCadena
  2564.     Case lnCentenas = 8
  2565.         lcCadena = 'OCHOCIENTOS ' + lcCadena
  2566.     Case lnCentenas = 9
  2567.         lcCadena = 'NOVECIENTOS ' + lcCadena
  2568.     Endcase
  2569.  
  2570. *--- Armo el retorno terna a terna
  2571.     lcRetorno = lcCadena + lcMiles + lcRetorno
  2572.     lnTerna = lnTerna + 1
  2573. Enddo
  2574. If lnTerna = 1
  2575.     lcRetorno = 'CERO '
  2576. Endif
  2577. Return lcRetorno
  2578. Endfu
  2579. *--------------------------------------------------------------------------
  2580. Function N2L(tnNro, tnFlag)
  2581. If Empty(tnFlag)
  2582.     tnFlag = 0
  2583. Endif
  2584. Local lnEntero, lcRetorno, lnTerna, lcMiles, ;
  2585.     lcCadena, lnUnidades, lnDecenas, lnCentenas
  2586. lnEntero = Int(tnNro)
  2587. lcRetorno = ''
  2588. lnTerna = 1
  2589. Do While lnEntero > 0
  2590.     lcCadena = ''
  2591.     lnUnidades = Mod(lnEntero, 10)
  2592.     lnEntero = Int(lnEntero / 10)
  2593.     lnDecenas = Mod(lnEntero, 10)
  2594.     lnEntero = Int(lnEntero / 10)
  2595.     lnCentenas = Mod(lnEntero, 10)
  2596.     lnEntero = Int(lnEntero / 10)
  2597. *--- Analizo la terna
  2598.     Do Case
  2599.     Case lnTerna = 1
  2600.         lcMiles = ''
  2601.     Case lnTerna = 2 And (lnUnidades + lnDecenas + lnCentenas # 0)
  2602.         lcMiles = 'MIL '
  2603.     Case lnTerna = 3 And (lnUnidades + lnDecenas + lnCentenas # 0)
  2604.         lcMiles = Iif(lnUnidades = 1 And lnDecenas = 0 And ;
  2605.             lnCentenas = 0, 'MILLON ', 'MILLONES ')
  2606.     Case lnTerna = 4 And (lnUnidades + lnDecenas + lnCentenas # 0)
  2607.         lcMiles = 'MIL MILLONES '
  2608.     Case lnTerna = 5 And (lnUnidades + lnDecenas + lnCentenas # 0)
  2609.         lcMiles = Iif(lnUnidades = 1 And lnDecenas = 0 And ;
  2610.             lnCentenas = 0, 'BILLON ', 'BILLONES ')
  2611.     Case lnTerna > 5
  2612.         lcRetorno = ' ERROR: NUMERO DEMASIADO GRANDE '
  2613.         Exit
  2614.     Endcase
  2615.  
  2616. *--- Analizo las unidades
  2617.     Do Case
  2618.     Case lnUnidades = 1
  2619.         lcCadena = Iif(lnTerna = 1 And tnFlag = 0, 'UNO ', 'UN ')
  2620.     Case lnUnidades = 2
  2621.         lcCadena = 'DOS '
  2622.     Case lnUnidades = 3
  2623.         lcCadena = 'TRES '
  2624.     Case lnUnidades = 4
  2625.         lcCadena = 'CUATRO '
  2626.     Case lnUnidades = 5
  2627.         lcCadena = 'CINCO '
  2628.     Case lnUnidades = 6
  2629.         lcCadena = 'SEIS '
  2630.     Case lnUnidades = 7
  2631.         lcCadena = 'SIETE '
  2632.     Case lnUnidades = 8
  2633.         lcCadena = 'OCHO '
  2634.     Case lnUnidades = 9
  2635.         lcCadena = 'NUEVE '
  2636.     Endcase
  2637.  
  2638. *--- Analizo las decenas
  2639.     Do Case
  2640.     Case lnDecenas = 1
  2641.         Do Case
  2642.         Case lnUnidades = 0
  2643.             lcCadena = 'DIEZ '
  2644.         Case lnUnidades = 1
  2645.             lcCadena = 'ONCE '
  2646.         Case lnUnidades = 2
  2647.             lcCadena = 'DOCE '
  2648.         Case lnUnidades = 3
  2649.             lcCadena = 'TRECE '
  2650.         Case lnUnidades = 4
  2651.             lcCadena = 'CATORCE '
  2652.         Case lnUnidades = 5
  2653.             lcCadena = 'QUINCE '
  2654.         Other
  2655.             lcCadena = 'DIECI' + lcCadena
  2656.         Endcase
  2657.     Case lnDecenas = 2
  2658.         lcCadena = Iif(lnUnidades = 0, 'VEINTE ', 'VEINTI') + lcCadena
  2659.     Case lnDecenas = 3
  2660.         lcCadena = 'TREINTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  2661.     Case lnDecenas = 4
  2662.         lcCadena = 'CUARENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  2663.     Case lnDecenas = 5
  2664.         lcCadena = 'CINCUENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  2665.     Case lnDecenas = 6
  2666.         lcCadena = 'SESENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  2667.     Case lnDecenas = 7
  2668.         lcCadena = 'SETENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  2669.     Case lnDecenas = 8
  2670.         lcCadena = 'OCHENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  2671.     Case lnDecenas = 9
  2672.         lcCadena = 'NOVENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  2673.     Endcase
  2674.  
  2675. *--- Analizo las centenas
  2676.     Do Case
  2677.     Case lnCentenas = 1
  2678.         lcCadena = Iif(lnUnidades = 0 And lnDecenas = 0, ;
  2679.             'CIEN ', 'CIENTO ') + lcCadena
  2680.     Case lnCentenas = 2
  2681.         lcCadena = 'DOSCIENTOS ' + lcCadena
  2682.     Case lnCentenas = 3
  2683.         lcCadena = 'TRESCIENTOS ' + lcCadena
  2684.     Case lnCentenas = 4
  2685.         lcCadena = 'CUATROCIENTOS ' + lcCadena
  2686.     Case lnCentenas = 5
  2687.         lcCadena = 'QUINIENTOS ' + lcCadena
  2688.     Case lnCentenas = 6
  2689.         lcCadena = 'SEISCIENTOS ' + lcCadena
  2690.     Case lnCentenas = 7
  2691.         lcCadena = 'SETECIENTOS ' + lcCadena
  2692.     Case lnCentenas = 8
  2693.         lcCadena = 'OCHOCIENTOS ' + lcCadena
  2694.     Case lnCentenas = 9
  2695.         lcCadena = 'NOVECIENTOS ' + lcCadena
  2696.     Endcase
  2697.  
  2698. *--- Armo el retorno terna a terna
  2699.     lcRetorno = lcCadena + lcMiles + lcRetorno
  2700.     lnTerna = lnTerna + 1
  2701. Enddo
  2702. If lnTerna = 1
  2703.     lcRetorno = 'CERO '
  2704. Endif
  2705. Return lcRetorno
  2706. Endfu
  2707. *--- Analizo la terna
  2708.     Do Case
  2709.     Case lnTerna = 1
  2710.         lcMiles = ''
  2711.     Case lnTerna = 2 And (lnUnidades + lnDecenas + lnCentenas # 0)
  2712.         lcMiles = 'MIL '
  2713.     Case lnTerna = 3 And (lnUnidades + lnDecenas + lnCentenas # 0)
  2714.         lcMiles = Iif(lnUnidades = 1 And lnDecenas = 0 And ;
  2715.             lnCentenas = 0, 'MILLON ', 'MILLONES ')
  2716.     Case lnTerna = 4 And (lnUnidades + lnDecenas + lnCentenas # 0)
  2717.         lcMiles = 'MIL MILLONES '
  2718.     Case lnTerna = 5 And (lnUnidades + lnDecenas + lnCentenas # 0)
  2719.         lcMiles = Iif(lnUnidades = 1 And lnDecenas = 0 And ;
  2720.             lnCentenas = 0, 'BILLON ', 'BILLONES ')
  2721.     Case lnTerna > 5
  2722.         lcRetorno = ' ERROR: NUMERO DEMASIADO GRANDE '
  2723.         Exit
  2724.     Endcase
  2725. *--- Analizo las unidades
  2726.     Do Case
  2727.     Case lnUnidades = 1
  2728.         lcCadena = Iif(lnTerna = 1 And tnFlag = 0, 'UNO ', 'UN ')
  2729.     Case lnUnidades = 2
  2730.         lcCadena = 'DOS '
  2731.     Case lnUnidades = 3
  2732.         lcCadena = 'TRES '
  2733.     Case lnUnidades = 4
  2734.         lcCadena = 'CUATRO '
  2735.     Case lnUnidades = 5
  2736.         lcCadena = 'CINCO '
  2737.     Case lnUnidades = 6
  2738.         lcCadena = 'SEIS '
  2739.     Case lnUnidades = 7
  2740.         lcCadena = 'SIETE '
  2741.     Case lnUnidades = 8
  2742.         lcCadena = 'OCHO '
  2743.     Case lnUnidades = 9
  2744.         lcCadena = 'NUEVE '
  2745.     Endcase
  2746.  
  2747. *--- Analizo las decenas
  2748.     Do Case
  2749.     Case lnDecenas = 1
  2750.         Do Case
  2751.         Case lnUnidades = 0
  2752.             lcCadena = 'DIEZ '
  2753.         Case lnUnidades = 1
  2754.             lcCadena = 'ONCE '
  2755.         Case lnUnidades = 2
  2756.             lcCadena = 'DOCE '
  2757.         Case lnUnidades = 3
  2758.             lcCadena = 'TRECE '
  2759.         Case lnUnidades = 4
  2760.             lcCadena = 'CATORCE '
  2761.         Case lnUnidades = 5
  2762.             lcCadena = 'QUINCE '
  2763.         Other
  2764.             lcCadena = 'DIECI' + lcCadena
  2765.         Endcase
  2766.     Case lnDecenas = 2
  2767.         lcCadena = Iif(lnUnidades = 0, 'VEINTE ', 'VEINTI') + lcCadena
  2768.     Case lnDecenas = 3
  2769.         lcCadena = 'TREINTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  2770.     Case lnDecenas = 4
  2771.         lcCadena = 'CUARENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  2772.     Case lnDecenas = 5
  2773.         lcCadena = 'CINCUENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  2774.     Case lnDecenas = 6
  2775.         lcCadena = 'SESENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  2776.     Case lnDecenas = 7
  2777.         lcCadena = 'SETENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  2778.     Case lnDecenas = 8
  2779.         lcCadena = 'OCHENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  2780.     Case lnDecenas = 9
  2781.         lcCadena = 'NOVENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  2782.     Endcase
  2783.  
  2784. *--- Analizo las centenas
  2785.     Do Case
  2786.     Case lnCentenas = 1
  2787.         lcCadena = Iif(lnUnidades = 0 And lnDecenas = 0, ;
  2788.             'CIEN ', 'CIENTO ') + lcCadena
  2789.     Case lnCentenas = 2
  2790.         lcCadena = 'DOSCIENTOS ' + lcCadena
  2791.     Case lnCentenas = 3
  2792.         lcCadena = 'TRESCIENTOS ' + lcCadena
  2793.     Case lnCentenas = 4
  2794.         lcCadena = 'CUATROCIENTOS ' + lcCadena
  2795.     Case lnCentenas = 5
  2796.         lcCadena = 'QUINIENTOS ' + lcCadena
  2797.     Case lnCentenas = 6
  2798.         lcCadena = 'SEISCIENTOS ' + lcCadena
  2799.     Case lnCentenas = 7
  2800.         lcCadena = 'SETECIENTOS ' + lcCadena
  2801.     Case lnCentenas = 8
  2802.         lcCadena = 'OCHOCIENTOS ' + lcCadena
  2803.     Case lnCentenas = 9
  2804.         lcCadena = 'NOVECIENTOS ' + lcCadena
  2805.     Endcase
  2806.  
  2807. *--- Armo el retorno terna a terna
  2808.     lcRetorno = lcCadena + lcMiles + lcRetorno
  2809.     lnTerna = lnTerna + 1
  2810. Enddo
  2811. If lnTerna = 1
  2812.     lcRetorno = 'CERO '
  2813. Endif
  2814. Return lcRetorno
  2815. Endfu
  2816. *--- Analizo las unidades
  2817.     Do Case
  2818.     Case lnUnidades = 1
  2819.         lcCadena = Iif(lnTerna = 1 And tnFlag = 0, 'UNO ', 'UN ')
  2820.     Case lnUnidades = 2
  2821.         lcCadena = 'DOS '
  2822.     Case lnUnidades = 3
  2823.         lcCadena = 'TRES '
  2824.     Case lnUnidades = 4
  2825.         lcCadena = 'CUATRO '
  2826.     Case lnUnidades = 5
  2827.         lcCadena = 'CINCO '
  2828.     Case lnUnidades = 6
  2829.         lcCadena = 'SEIS '
  2830.     Case lnUnidades = 7
  2831.         lcCadena = 'SIETE '
  2832.     Case lnUnidades = 8
  2833.         lcCadena = 'OCHO '
  2834.     Case lnUnidades = 9
  2835.         lcCadena = 'NUEVE '
  2836.     Endcase
  2837. *--- Analizo las decenas
  2838.     Do Case
  2839.     Case lnDecenas = 1
  2840.         Do Case
  2841.         Case lnUnidades = 0
  2842.             lcCadena = 'DIEZ '
  2843.         Case lnUnidades = 1
  2844.             lcCadena = 'ONCE '
  2845.         Case lnUnidades = 2
  2846.             lcCadena = 'DOCE '
  2847.         Case lnUnidades = 3
  2848.             lcCadena = 'TRECE '
  2849.         Case lnUnidades = 4
  2850.             lcCadena = 'CATORCE '
  2851.         Case lnUnidades = 5
  2852.             lcCadena = 'QUINCE '
  2853.         Other
  2854.             lcCadena = 'DIECI' + lcCadena
  2855.         Endcase
  2856.     Case lnDecenas = 2
  2857.         lcCadena = Iif(lnUnidades = 0, 'VEINTE ', 'VEINTI') + lcCadena
  2858.     Case lnDecenas = 3
  2859.         lcCadena = 'TREINTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  2860.     Case lnDecenas = 4
  2861.         lcCadena = 'CUARENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  2862.     Case lnDecenas = 5
  2863.         lcCadena = 'CINCUENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  2864.     Case lnDecenas = 6
  2865.         lcCadena = 'SESENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  2866.     Case lnDecenas = 7
  2867.         lcCadena = 'SETENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  2868.     Case lnDecenas = 8
  2869.         lcCadena = 'OCHENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  2870.     Case lnDecenas = 9
  2871.         lcCadena = 'NOVENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  2872.     Endcase
  2873.  
  2874. *--- Analizo las centenas
  2875.     Do Case
  2876.     Case lnCentenas = 1
  2877.         lcCadena = Iif(lnUnidades = 0 And lnDecenas = 0, ;
  2878.             'CIEN ', 'CIENTO ') + lcCadena
  2879.     Case lnCentenas = 2
  2880.         lcCadena = 'DOSCIENTOS ' + lcCadena
  2881.     Case lnCentenas = 3
  2882.         lcCadena = 'TRESCIENTOS ' + lcCadena
  2883.     Case lnCentenas = 4
  2884.         lcCadena = 'CUATROCIENTOS ' + lcCadena
  2885.     Case lnCentenas = 5
  2886.         lcCadena = 'QUINIENTOS ' + lcCadena
  2887.     Case lnCentenas = 6
  2888.         lcCadena = 'SEISCIENTOS ' + lcCadena
  2889.     Case lnCentenas = 7
  2890.         lcCadena = 'SETECIENTOS ' + lcCadena
  2891.     Case lnCentenas = 8
  2892.         lcCadena = 'OCHOCIENTOS ' + lcCadena
  2893.     Case lnCentenas = 9
  2894.         lcCadena = 'NOVECIENTOS ' + lcCadena
  2895.     Endcase
  2896.  
  2897. *--- Armo el retorno terna a terna
  2898.     lcRetorno = lcCadena + lcMiles + lcRetorno
  2899.     lnTerna = lnTerna + 1
  2900. Enddo
  2901. If lnTerna = 1
  2902.     lcRetorno = 'CERO '
  2903. Endif
  2904. Return lcRetorno
  2905. Endfu
  2906. *--- Analizo las decenas
  2907.     Do Case
  2908.     Case lnDecenas = 1
  2909.         Do Case
  2910.         Case lnUnidades = 0
  2911.             lcCadena = 'DIEZ '
  2912.         Case lnUnidades = 1
  2913.             lcCadena = 'ONCE '
  2914.         Case lnUnidades = 2
  2915.             lcCadena = 'DOCE '
  2916.         Case lnUnidades = 3
  2917.             lcCadena = 'TRECE '
  2918.         Case lnUnidades = 4
  2919.             lcCadena = 'CATORCE '
  2920.         Case lnUnidades = 5
  2921.             lcCadena = 'QUINCE '
  2922.         Other
  2923.             lcCadena = 'DIECI' + lcCadena
  2924.         Endcase
  2925.     Case lnDecenas = 2
  2926.         lcCadena = Iif(lnUnidades = 0, 'VEINTE ', 'VEINTI') + lcCadena
  2927.     Case lnDecenas = 3
  2928.         lcCadena = 'TREINTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  2929.     Case lnDecenas = 4
  2930.         lcCadena = 'CUARENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  2931.     Case lnDecenas = 5
  2932.         lcCadena = 'CINCUENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  2933.     Case lnDecenas = 6
  2934.         lcCadena = 'SESENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  2935.     Case lnDecenas = 7
  2936.         lcCadena = 'SETENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  2937.     Case lnDecenas = 8
  2938.         lcCadena = 'OCHENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  2939.     Case lnDecenas = 9
  2940.         lcCadena = 'NOVENTA ' + Iif(lnUnidades = 0, '', 'Y ') + lcCadena
  2941.     Endcase
  2942. *--- Analizo las centenas
  2943.     Do Case
  2944.     Case lnCentenas = 1
  2945.         lcCadena = Iif(lnUnidades = 0 And lnDecenas = 0, ;
  2946.             'CIEN ', 'CIENTO ') + lcCadena
  2947.     Case lnCentenas = 2
  2948.         lcCadena = 'DOSCIENTOS ' + lcCadena
  2949.     Case lnCentenas = 3
  2950.         lcCadena = 'TRESCIENTOS ' + lcCadena
  2951.     Case lnCentenas = 4
  2952.         lcCadena = 'CUATROCIENTOS ' + lcCadena
  2953.     Case lnCentenas = 5
  2954.         lcCadena = 'QUINIENTOS ' + lcCadena
  2955.     Case lnCentenas = 6
  2956.         lcCadena = 'SEISCIENTOS ' + lcCadena
  2957.     Case lnCentenas = 7
  2958.         lcCadena = 'SETECIENTOS ' + lcCadena
  2959.     Case lnCentenas = 8
  2960.         lcCadena = 'OCHOCIENTOS ' + lcCadena
  2961.     Case lnCentenas = 9
  2962.         lcCadena = 'NOVECIENTOS ' + lcCadena
  2963.     Endcase
  2964.  
  2965. *--- Armo el retorno terna a terna
  2966.     lcRetorno = lcCadena + lcMiles + lcRetorno
  2967.     lnTerna = lnTerna + 1
  2968. Enddo
  2969. If lnTerna = 1
  2970.     lcRetorno = 'CERO '
  2971. Endif
  2972. Return lcRetorno
  2973. Endfu
  2974. *--- Analizo las centenas
  2975.     Do Case
  2976.     Case lnCentenas = 1
  2977.         lcCadena = Iif(lnUnidades = 0 And lnDecenas = 0, ;
  2978.             'CIEN ', 'CIENTO ') + lcCadena
  2979.     Case lnCentenas = 2
  2980.         lcCadena = 'DOSCIENTOS ' + lcCadena
  2981.     Case lnCentenas = 3
  2982.         lcCadena = 'TRESCIENTOS ' + lcCadena
  2983.     Case lnCentenas = 4
  2984.         lcCadena = 'CUATROCIENTOS ' + lcCadena
  2985.     Case lnCentenas = 5
  2986.         lcCadena = 'QUINIENTOS ' + lcCadena
  2987.     Case lnCentenas = 6
  2988.         lcCadena = 'SEISCIENTOS ' + lcCadena
  2989.     Case lnCentenas = 7
  2990.         lcCadena = 'SETECIENTOS ' + lcCadena
  2991.     Case lnCentenas = 8
  2992.         lcCadena = 'OCHOCIENTOS ' + lcCadena
  2993.     Case lnCentenas = 9
  2994.         lcCadena = 'NOVECIENTOS ' + lcCadena
  2995.     Endcase
  2996. *--- Armo el retorno terna a terna
  2997.     lcRetorno = lcCadena + lcMiles + lcRetorno
  2998.     lnTerna = lnTerna + 1
  2999. Enddo
  3000. If lnTerna = 1
  3001.     lcRetorno = 'CERO '
  3002. Endif
  3003. Return lcRetorno
  3004. Endfu
  3005. *--- Armo el retorno terna a terna
  3006.     lcRetorno = lcCadena + lcMiles + lcRetorno
  3007.     lnTerna = lnTerna + 1
  3008. Enddo
  3009. If lnTerna = 1
  3010.     lcRetorno = 'CERO '
  3011. Endif
  3012. Return lcRetorno
  3013. Endfunc
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
Top