00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028 #include "stdio.h"
00029 #include <string.h>
00030 #include "cr-input.h"
00031 #include "cr-enc-handler.h"
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042
00043
00044
00045
00046
00047
00048 struct _CRInputPriv
00049 {
00050
00051
00052
00053 guchar *in_buf ;
00054 gulong in_buf_size ;
00055
00056 gulong nb_bytes ;
00057
00058
00059
00060
00061
00062 gulong next_byte_index ;
00063
00064
00065
00066
00067 gulong line ;
00068
00069
00070
00071
00072 gulong col ;
00073
00074 gboolean end_of_line ;
00075 gboolean end_of_input ;
00076
00077
00078
00079
00080
00081 guint ref_count ;
00082 gboolean free_in_buf ;
00083 } ;
00084
00085
00086 #define PRIVATE(object) (object)->priv
00087
00088
00089
00090
00091
00092 #define CR_INPUT_MEM_CHUNK_SIZE 1024 * 4
00093
00094 static CRInput *
00095 cr_input_new_real (void) ;
00096
00097
00098 static CRInput *
00099 cr_input_new_real (void)
00100 {
00101 CRInput *result = NULL ;
00102
00103 result = g_try_malloc (sizeof (CRInput)) ;
00104 if (!result)
00105 {
00106 cr_utils_trace_info ("Out of memory") ;
00107 return NULL ;
00108 }
00109 memset (result, 0, sizeof (CRInput)) ;
00110
00111 PRIVATE (result) = g_try_malloc (sizeof (CRInputPriv)) ;
00112 if (!PRIVATE (result))
00113 {
00114 cr_utils_trace_info ("Out of memory") ;
00115 g_free (result) ;
00116 return NULL ;
00117 }
00118 memset (PRIVATE (result), 0, sizeof (CRInputPriv)) ;
00119 PRIVATE (result)->free_in_buf = TRUE ;
00120 return result ;
00121 }
00122
00123
00124
00125
00126
00127
00128
00129
00130
00131
00132
00133
00134
00135
00136
00137
00138
00139 CRInput *
00140 cr_input_new_from_buf (const guchar *a_buf,
00141 gulong a_len,
00142 enum CREncoding a_enc,
00143 gboolean a_free_buf)
00144 {
00145 CRInput *result = NULL;
00146 enum CRStatus status = CR_OK ;
00147 CREncHandler *enc_handler = NULL ;
00148 gulong len = a_len ;
00149 g_return_val_if_fail (a_buf, NULL) ;
00150
00151 result = cr_input_new_real () ;
00152 g_return_val_if_fail (result, NULL) ;
00153
00154
00155 if (a_enc != CR_UTF_8)
00156 {
00157 enc_handler = cr_enc_handler_get_instance (a_enc) ;
00158 if (!enc_handler)
00159 {
00160 goto error ;
00161 }
00162
00163 status = cr_enc_handler_convert_input
00164 (enc_handler, a_buf, &len,
00165 &PRIVATE (result)->in_buf,
00166 &PRIVATE (result)->in_buf_size) ;
00167
00168 if (status != CR_OK)
00169 goto error ;
00170
00171 PRIVATE (result)->line = 1 ;
00172 PRIVATE (result)->nb_bytes = PRIVATE (result)->in_buf_size ;
00173 }
00174 else
00175 {
00176 PRIVATE (result)->in_buf = (guchar *) a_buf ;
00177 PRIVATE (result)->in_buf_size = a_len ;
00178 PRIVATE (result)->nb_bytes = a_len ;
00179 }
00180
00181 PRIVATE (result)->free_in_buf = a_free_buf ;
00182
00183 return result ;
00184
00185 error:
00186 if (result)
00187 {
00188 cr_input_destroy (result) ;
00189 result = NULL ;
00190 }
00191
00192 return NULL ;
00193 }
00194
00195
00196
00197
00198
00199
00200
00201
00202
00203
00204
00205
00206
00207 CRInput *
00208 cr_input_new_from_uri (const gchar *a_file_uri, enum CREncoding a_enc)
00209 {
00210 CRInput * result = NULL ;
00211 enum CRStatus status = CR_OK ;
00212 FILE * file_ptr = NULL ;
00213 guchar tmp_buf[CR_INPUT_MEM_CHUNK_SIZE] = {0} ;
00214 gulong nb_read = 0, len = 0, buf_size = 0 ;
00215 gboolean loop = TRUE ;
00216 guchar *buf = NULL ;
00217
00218 g_return_val_if_fail (a_file_uri, NULL) ;
00219
00220 file_ptr = fopen (a_file_uri, "r") ;
00221
00222 if (file_ptr == NULL)
00223 {
00224
00225 #ifdef CR_DEBUG
00226 cr_utils_trace_debug ("could not open file") ;
00227 #endif
00228 g_warning ("Could not open file %s\n", a_file_uri) ;
00229
00230 return NULL ;
00231 }
00232
00233
00234 while (loop)
00235 {
00236 nb_read =
00237 fread (tmp_buf, 1,
00238 CR_INPUT_MEM_CHUNK_SIZE,
00239 file_ptr) ;
00240
00241 if (nb_read != CR_INPUT_MEM_CHUNK_SIZE)
00242 {
00243
00244 if (feof (file_ptr))
00245 {
00246
00247 loop = FALSE ;
00248 }
00249 else
00250 {
00251
00252 cr_utils_trace_debug
00253 ("an io error occured") ;
00254 status = CR_ERROR ;
00255 goto cleanup ;
00256 }
00257 }
00258
00259 if (status == CR_OK)
00260 {
00261
00262 buf = g_realloc
00263 (buf, len + CR_INPUT_MEM_CHUNK_SIZE) ;
00264 memcpy (buf + len, tmp_buf, nb_read) ;
00265 len += nb_read ;
00266 buf_size += CR_INPUT_MEM_CHUNK_SIZE ;
00267 }
00268 }
00269
00270
00271 if (status == CR_OK)
00272 {
00273 result = cr_input_new_from_buf (buf, len, a_enc,
00274 TRUE) ;
00275 if (!result)
00276 {
00277 goto cleanup ;
00278 }
00279 }
00280
00281 cleanup:
00282
00283 if (file_ptr)
00284 {
00285 fclose (file_ptr) ;
00286 file_ptr = NULL ;
00287 }
00288
00289 if (buf)
00290 {
00291 g_free (buf) ;
00292 buf = NULL ;
00293 }
00294
00295 return result ;
00296 }
00297
00298
00299
00300
00301
00302 void
00303 cr_input_destroy (CRInput *a_this)
00304 {
00305 if (a_this == NULL)
00306 return ;
00307
00308 if (PRIVATE (a_this))
00309 {
00310 if (PRIVATE (a_this)->in_buf
00311 && PRIVATE (a_this)->free_in_buf)
00312 {
00313 g_free (PRIVATE (a_this)->in_buf) ;
00314 PRIVATE (a_this)->in_buf = NULL ;
00315 }
00316
00317 g_free (PRIVATE (a_this)) ;
00318 PRIVATE (a_this) = NULL ;
00319 }
00320
00321 g_free (a_this) ;
00322 }
00323
00324
00325
00326
00327
00328
00329
00330 void
00331 cr_input_ref (CRInput *a_this)
00332 {
00333 g_return_if_fail (a_this && PRIVATE (a_this)) ;
00334
00335 PRIVATE (a_this)->ref_count ++ ;
00336 }
00337
00338
00339
00340
00341
00342
00343
00344
00345
00346 gboolean
00347 cr_input_unref (CRInput *a_this)
00348 {
00349 g_return_val_if_fail (a_this && PRIVATE (a_this), FALSE) ;
00350
00351 if (PRIVATE (a_this)->ref_count)
00352 {
00353 PRIVATE (a_this)->ref_count -- ;
00354 }
00355
00356 if (PRIVATE (a_this)->ref_count == 0)
00357 {
00358 cr_input_destroy (a_this) ;
00359 return TRUE ;
00360 }
00361 return FALSE ;
00362 }
00363
00364
00365
00366
00367
00368
00369
00370
00371
00372
00373
00374
00375
00376 enum CRStatus
00377 cr_input_end_of_input (CRInput *a_this, gboolean *a_end_of_input)
00378 {
00379 g_return_val_if_fail (a_this && PRIVATE (a_this)
00380 && a_end_of_input, CR_BAD_PARAM_ERROR) ;
00381
00382 *a_end_of_input = (PRIVATE (a_this)->next_byte_index
00383 >= PRIVATE (a_this)->in_buf_size)? TRUE : FALSE ;
00384
00385 return CR_OK ;
00386 }
00387
00388
00389
00390
00391
00392
00393
00394
00395 glong
00396 cr_input_get_nb_bytes_left (CRInput *a_this)
00397 {
00398 g_return_val_if_fail (a_this && PRIVATE (a_this), -1) ;
00399 g_return_val_if_fail (PRIVATE (a_this)->nb_bytes
00400 <= PRIVATE (a_this)->in_buf_size, -1) ;
00401 g_return_val_if_fail (PRIVATE (a_this)->next_byte_index
00402 <= PRIVATE (a_this)->nb_bytes, -1) ;
00403
00404 if (PRIVATE (a_this)->end_of_input)
00405 return 0 ;
00406
00407 return PRIVATE (a_this)->nb_bytes
00408 - PRIVATE (a_this)->next_byte_index ;
00409 }
00410
00411
00412
00413
00414
00415
00416
00417
00418
00419
00420
00421
00422
00423
00424 enum CRStatus
00425 cr_input_read_byte (CRInput *a_this, guchar *a_byte)
00426 {
00427 g_return_val_if_fail (a_this
00428 && PRIVATE (a_this)
00429 && a_byte,
00430 CR_BAD_PARAM_ERROR) ;
00431
00432 g_return_val_if_fail (PRIVATE (a_this)->next_byte_index <=
00433 PRIVATE (a_this)->nb_bytes,
00434 CR_BAD_PARAM_ERROR) ;
00435
00436 if (PRIVATE (a_this)->end_of_input == TRUE)
00437 return CR_END_OF_INPUT_ERROR ;
00438
00439 *a_byte =
00440 PRIVATE
00441 (a_this)->in_buf[PRIVATE (a_this)->next_byte_index] ;
00442
00443 if (PRIVATE (a_this)->nb_bytes -
00444 PRIVATE (a_this)->next_byte_index < 2)
00445 {
00446 PRIVATE (a_this)->end_of_input = TRUE ;
00447 }
00448 else
00449 {
00450 PRIVATE (a_this)->next_byte_index ++ ;
00451 }
00452
00453 return CR_OK ;
00454 }
00455
00456
00457
00458
00459
00460
00461
00462
00463
00464
00465 enum CRStatus
00466 cr_input_read_char (CRInput *a_this, guint32 *a_char)
00467 {
00468 enum CRStatus status = CR_OK ;
00469 gulong consumed = 0, nb_bytes_left = 0 ;
00470
00471 g_return_val_if_fail (a_this && PRIVATE (a_this) && a_char,
00472 CR_BAD_PARAM_ERROR) ;
00473
00474 if (PRIVATE (a_this)->end_of_input == TRUE)
00475 return CR_END_OF_INPUT_ERROR ;
00476
00477 nb_bytes_left = cr_input_get_nb_bytes_left (a_this) ;
00478
00479 if (nb_bytes_left < 1)
00480 {
00481 return CR_END_OF_INPUT_ERROR ;
00482 }
00483
00484 status =
00485 cr_utils_read_char_from_utf8_buf
00486 (PRIVATE (a_this)->in_buf
00487 +
00488 PRIVATE (a_this)->next_byte_index,
00489 nb_bytes_left, a_char, &consumed) ;
00490
00491 if (status == CR_OK)
00492 {
00493
00494 PRIVATE (a_this)->next_byte_index += consumed ;
00495
00496
00497 if (PRIVATE (a_this)->end_of_line == TRUE)
00498 {
00499 PRIVATE (a_this)->col = 1 ;
00500 PRIVATE (a_this)->line ++ ;
00501 PRIVATE (a_this)->end_of_line = FALSE ;
00502 }
00503 else if (*a_char != '\n')
00504 {
00505 PRIVATE (a_this)->col ++ ;
00506 }
00507
00508 if (*a_char == '\n')
00509 {
00510 PRIVATE (a_this)->end_of_line = TRUE ;
00511 }
00512
00513 }
00514
00515 return status ;
00516 }
00517
00518
00519
00520
00521
00522
00523
00524
00525
00526 enum CRStatus
00527 cr_input_set_line_num (CRInput *a_this, glong a_line_num)
00528 {
00529 g_return_val_if_fail (a_this && PRIVATE (a_this),
00530 CR_BAD_PARAM_ERROR) ;
00531
00532 PRIVATE (a_this)->line = a_line_num ;
00533
00534 return CR_OK ;
00535 }
00536
00537
00538
00539
00540
00541
00542
00543
00544
00545 enum CRStatus
00546 cr_input_get_line_num (CRInput *a_this, glong *a_line_num)
00547 {
00548 g_return_val_if_fail (a_this && PRIVATE (a_this)
00549 && a_line_num,
00550 CR_BAD_PARAM_ERROR) ;
00551
00552 *a_line_num = PRIVATE (a_this)->line ;
00553
00554 return CR_OK ;
00555 }
00556
00557
00558
00559
00560
00561
00562
00563
00564
00565 enum CRStatus
00566 cr_input_set_column_num (CRInput *a_this, glong a_col)
00567 {
00568 g_return_val_if_fail (a_this && PRIVATE (a_this),
00569 CR_BAD_PARAM_ERROR) ;
00570
00571 PRIVATE (a_this)->col = a_col ;
00572
00573 return CR_OK ;
00574 }
00575
00576
00577
00578
00579
00580
00581
00582
00583
00584 enum CRStatus
00585 cr_input_get_column_num (CRInput *a_this, glong *a_col)
00586 {
00587 g_return_val_if_fail (a_this && PRIVATE (a_this) && a_col,
00588 CR_BAD_PARAM_ERROR) ;
00589
00590 *a_col = PRIVATE (a_this)->col ;
00591
00592 return CR_OK ;
00593 }
00594
00595
00596
00597
00598
00599
00600
00601
00602 enum CRStatus
00603 cr_input_increment_line_num (CRInput *a_this, glong a_increment)
00604 {
00605 g_return_val_if_fail (a_this && PRIVATE (a_this),
00606 CR_BAD_PARAM_ERROR) ;
00607
00608 PRIVATE (a_this)->line += a_increment ;
00609
00610 return CR_OK ;
00611 }
00612
00613
00614
00615
00616
00617
00618
00619
00620 enum CRStatus
00621 cr_input_increment_col_num (CRInput *a_this, glong a_increment)
00622 {
00623 g_return_val_if_fail (a_this && PRIVATE (a_this),
00624 CR_BAD_PARAM_ERROR) ;
00625
00626 PRIVATE (a_this)->col += a_increment ;
00627
00628 return CR_OK ;
00629 }
00630
00631
00632
00633
00634
00635
00636
00637
00638
00639
00640
00641
00642
00643 enum CRStatus
00644 cr_input_consume_char (CRInput *a_this, guint32 a_char)
00645 {
00646 guint32 c ;
00647 enum CRStatus status ;
00648
00649 g_return_val_if_fail (a_this && PRIVATE (a_this),
00650 CR_BAD_PARAM_ERROR) ;
00651
00652 if ((status = cr_input_peek_char (a_this, &c)) != CR_OK)
00653 {
00654 return status ;
00655 }
00656
00657 if (c == a_char || a_char == 0)
00658 {
00659 status = cr_input_read_char (a_this, &c) ;
00660 }
00661 else
00662 {
00663 return CR_PARSING_ERROR ;
00664 }
00665
00666 return status ;
00667 }
00668
00669
00670
00671
00672
00673
00674
00675
00676
00677
00678
00679
00680
00681
00682
00683
00684
00685
00686
00687
00688 enum CRStatus
00689 cr_input_consume_chars (CRInput *a_this, guint32 a_char, gulong *a_nb_char)
00690 {
00691 enum CRStatus status = CR_OK ;
00692 gulong nb_consumed = 0 ;
00693
00694 g_return_val_if_fail (a_this && PRIVATE (a_this) && a_nb_char,
00695 CR_BAD_PARAM_ERROR) ;
00696
00697 g_return_val_if_fail (a_char != 0 || a_nb_char != NULL,
00698 CR_BAD_PARAM_ERROR) ;
00699
00700 for (nb_consumed = 0 ;
00701 ((status == CR_OK)
00702 && (*a_nb_char > 0 && nb_consumed < *a_nb_char)) ;
00703 nb_consumed ++)
00704 {
00705 status = cr_input_consume_char (a_this, a_char) ;
00706 }
00707
00708 *a_nb_char = nb_consumed ;
00709
00710 if ((nb_consumed > 0)
00711 && ((status == CR_PARSING_ERROR)
00712 || (status == CR_END_OF_INPUT_ERROR)))
00713 {
00714 status = CR_OK ;
00715 }
00716
00717 return status ;
00718 }
00719
00720
00721
00722
00723
00724
00725
00726
00727
00728
00729 enum CRStatus
00730 cr_input_consume_white_spaces (CRInput *a_this, gulong *a_nb_chars)
00731 {
00732 enum CRStatus status = CR_OK ;
00733 guint32 cur_char = 0, nb_consumed = 0 ;
00734
00735 g_return_val_if_fail (a_this && PRIVATE (a_this) && a_nb_chars,
00736 CR_BAD_PARAM_ERROR) ;
00737
00738 for (nb_consumed = 0;
00739 ((*a_nb_chars > 0) && (nb_consumed < *a_nb_chars)) ;
00740 nb_consumed ++)
00741 {
00742 status = cr_input_peek_char (a_this, &cur_char) ;
00743 if (status != CR_OK) break ;
00744
00745
00746 if (cr_utils_is_white_space (cur_char) == TRUE)
00747 {
00748 status = cr_input_read_char (a_this, &cur_char) ;
00749 if (status != CR_OK) break ;
00750 continue ;
00751 }
00752
00753 break ;
00754
00755 }
00756
00757 if (nb_consumed && status == CR_END_OF_INPUT_ERROR)
00758 {
00759 status = CR_OK ;
00760 }
00761
00762 return status ;
00763 }
00764
00765
00766
00767
00768
00769
00770
00771
00772
00773
00774
00775
00776 enum CRStatus
00777 cr_input_peek_char (CRInput *a_this, guint32 *a_char)
00778 {
00779 enum CRStatus status = CR_OK ;
00780 glong consumed = 0, nb_bytes_left = 0 ;
00781
00782 g_return_val_if_fail (a_this && PRIVATE (a_this)
00783 && a_char, CR_BAD_PARAM_ERROR) ;
00784
00785 if (PRIVATE (a_this)->next_byte_index >=
00786 PRIVATE (a_this)->in_buf_size)
00787 {
00788 return CR_END_OF_INPUT_ERROR ;
00789 }
00790
00791 nb_bytes_left = cr_input_get_nb_bytes_left (a_this) ;
00792
00793 if (nb_bytes_left < 1)
00794 {
00795 return CR_END_OF_INPUT_ERROR ;
00796 }
00797
00798 status =
00799 cr_utils_read_char_from_utf8_buf
00800 (PRIVATE (a_this)->in_buf +
00801 PRIVATE (a_this)->next_byte_index,
00802 nb_bytes_left, a_char, &consumed) ;
00803
00804 return status ;
00805 }
00806
00807
00808
00809
00810
00811
00812
00813
00814
00815
00816
00817
00818
00819
00820
00821
00822
00823
00824
00825
00826
00827
00828
00829
00830 enum CRStatus
00831 cr_input_peek_byte (CRInput *a_this, enum CRSeekPos a_origin,
00832 gulong a_offset, guchar *a_byte)
00833 {
00834 gulong abs_offset = 0 ;
00835
00836 g_return_val_if_fail (a_this && PRIVATE (a_this)
00837 && a_byte,
00838 CR_BAD_PARAM_ERROR) ;
00839
00840
00841 switch (a_origin) {
00842
00843 case CR_SEEK_CUR:
00844 abs_offset =
00845 PRIVATE (a_this)->next_byte_index - 1 + a_offset ;
00846 break ;
00847
00848 case CR_SEEK_BEGIN:
00849 abs_offset = a_offset ;
00850 break ;
00851
00852 case CR_SEEK_END:
00853 abs_offset =
00854 PRIVATE (a_this)->in_buf_size - 1 - a_offset ;
00855 break;
00856
00857 default:
00858 return CR_BAD_PARAM_ERROR ;
00859 }
00860
00861 if (abs_offset < PRIVATE (a_this)->in_buf_size) {
00862
00863 *a_byte =
00864 PRIVATE (a_this)->in_buf[abs_offset] ;
00865
00866 return CR_OK ;
00867
00868 } else {
00869 return CR_END_OF_INPUT_ERROR ;
00870 }
00871 }
00872
00873
00874
00875
00876
00877
00878
00879
00880
00881
00882
00883
00884 guchar
00885 cr_input_peek_byte2 (CRInput *a_this, gulong a_offset,
00886 gboolean *a_eof)
00887 {
00888 guchar result = 0 ;
00889 enum CRStatus status = CR_ERROR ;
00890
00891 g_return_val_if_fail (a_this && PRIVATE (a_this),
00892 0) ;
00893
00894 if (a_eof)
00895 *a_eof = FALSE ;
00896
00897 status = cr_input_peek_byte (a_this, CR_SEEK_CUR, a_offset,
00898 &result) ;
00899
00900 if ((status == CR_END_OF_INPUT_ERROR)
00901 && a_eof)
00902 *a_eof = TRUE ;
00903
00904 return result ;
00905 }
00906
00907
00908
00909
00910
00911
00912
00913
00914
00915
00916 guchar *
00917 cr_input_get_byte_addr (CRInput *a_this,
00918 gulong a_offset)
00919 {
00920 g_return_val_if_fail (a_this && PRIVATE (a_this), NULL) ;
00921
00922 if (a_offset >= PRIVATE (a_this)->nb_bytes)
00923 {
00924 return NULL ;
00925 }
00926
00927 return &PRIVATE (a_this)->in_buf[a_offset] ;
00928 }
00929
00930
00931
00932
00933
00934
00935
00936 enum CRStatus
00937 cr_input_get_cur_byte_addr (CRInput *a_this, guchar ** a_offset)
00938 {
00939 g_return_val_if_fail (a_this && PRIVATE (a_this) && a_offset,
00940 CR_BAD_PARAM_ERROR) ;
00941
00942 if (!PRIVATE (a_this)->next_byte_index)
00943 {
00944 return CR_START_OF_INPUT_ERROR ;
00945 }
00946
00947 *a_offset = cr_input_get_byte_addr
00948 (a_this, PRIVATE (a_this)->next_byte_index -1) ;
00949
00950 return CR_OK ;
00951 }
00952
00953
00954
00955
00956
00957
00958
00959
00960
00961
00962
00963
00964
00965
00966
00967
00968
00969
00970
00971
00972 enum CRStatus
00973 cr_input_seek_index (CRInput *a_this, enum CRSeekPos a_origin, gint a_pos)
00974 {
00975
00976 glong abs_offset = 0 ;
00977
00978 g_return_val_if_fail (a_this && PRIVATE (a_this), CR_BAD_PARAM_ERROR) ;
00979
00980
00981 switch (a_origin) {
00982
00983 case CR_SEEK_CUR:
00984 abs_offset =
00985 PRIVATE (a_this)->next_byte_index - 1 + a_pos ;
00986 break ;
00987
00988 case CR_SEEK_BEGIN:
00989 abs_offset = a_pos ;
00990 break ;
00991
00992 case CR_SEEK_END:
00993 abs_offset =
00994 PRIVATE (a_this)->in_buf_size - 1 - a_pos ;
00995 break ;
00996
00997 default:
00998 return CR_BAD_PARAM_ERROR ;
00999 }
01000
01001 if ((abs_offset > 0)
01002 && (gulong) abs_offset < PRIVATE (a_this)->nb_bytes) {
01003
01004
01005 PRIVATE (a_this)->next_byte_index = abs_offset + 1 ;
01006
01007 return CR_OK ;
01008 }
01009
01010 return CR_OUT_OF_BOUNDS_ERROR ;
01011 }
01012
01013
01014
01015
01016
01017
01018
01019
01020
01021
01022
01023
01024
01025
01026
01027
01028
01029
01030
01031
01032
01033 enum CRStatus
01034 cr_input_get_cur_pos (CRInput *a_this, CRInputPos * a_pos)
01035 {
01036 g_return_val_if_fail (a_this && PRIVATE (a_this) && a_pos,
01037 CR_BAD_PARAM_ERROR) ;
01038
01039 a_pos->next_byte_index = PRIVATE (a_this)->next_byte_index ;
01040 a_pos->line = PRIVATE (a_this)->line ;
01041 a_pos->col = PRIVATE (a_this)->col ;
01042 a_pos->end_of_line = PRIVATE (a_this)->end_of_line ;
01043 a_pos->end_of_file = PRIVATE (a_this)->end_of_input ;
01044
01045 return CR_OK ;
01046 }
01047
01048
01049
01050
01051
01052
01053
01054
01055
01056
01057
01058
01059 enum CRStatus
01060 cr_input_get_cur_index (CRInput *a_this, glong *a_index)
01061 {
01062 g_return_val_if_fail (a_this && PRIVATE (a_this)
01063 && a_index,
01064 CR_BAD_PARAM_ERROR) ;
01065
01066 *a_index = PRIVATE (a_this)->next_byte_index ;
01067
01068 return CR_OK ;
01069 }
01070
01071
01072
01073
01074
01075
01076
01077
01078
01079
01080 enum CRStatus
01081 cr_input_set_cur_index (CRInput *a_this, glong a_index)
01082 {
01083 g_return_val_if_fail (a_this && PRIVATE (a_this),
01084 CR_BAD_PARAM_ERROR) ;
01085
01086 PRIVATE (a_this)->next_byte_index = a_index ;
01087
01088 return CR_OK ;
01089 }
01090
01091
01092
01093
01094
01095
01096
01097
01098 enum CRStatus
01099 cr_input_set_end_of_file (CRInput *a_this, gboolean a_eof)
01100 {
01101 g_return_val_if_fail (a_this && PRIVATE (a_this),
01102 CR_BAD_PARAM_ERROR) ;
01103
01104 PRIVATE (a_this)->end_of_input = a_eof ;
01105
01106 return CR_OK ;
01107 }
01108
01109
01110
01111
01112
01113
01114
01115
01116 enum CRStatus
01117 cr_input_get_end_of_file (CRInput *a_this, gboolean *a_eof)
01118 {
01119 g_return_val_if_fail (a_this && PRIVATE (a_this)
01120 && a_eof,
01121 CR_BAD_PARAM_ERROR) ;
01122
01123 *a_eof = PRIVATE (a_this)->end_of_input ;
01124
01125 return CR_OK ;
01126 }
01127
01128
01129
01130
01131
01132
01133
01134
01135
01136 enum CRStatus
01137 cr_input_set_end_of_line (CRInput *a_this, gboolean a_eol)
01138 {
01139 g_return_val_if_fail (a_this && PRIVATE (a_this),
01140 CR_BAD_PARAM_ERROR) ;
01141
01142 PRIVATE (a_this)->end_of_line = a_eol ;
01143
01144 return CR_OK ;
01145 }
01146
01147
01148
01149
01150
01151
01152
01153
01154
01155 enum CRStatus
01156 cr_input_get_end_of_line (CRInput *a_this, gboolean *a_eol)
01157 {
01158 g_return_val_if_fail (a_this && PRIVATE (a_this)
01159 && a_eol,
01160 CR_BAD_PARAM_ERROR) ;
01161
01162 *a_eol = PRIVATE (a_this)->end_of_line ;
01163
01164 return CR_OK ;
01165 }
01166
01167
01168
01169
01170
01171
01172
01173
01174
01175 enum CRStatus
01176 cr_input_set_cur_pos (CRInput *a_this, CRInputPos *a_pos)
01177 {
01178 g_return_val_if_fail (a_this && PRIVATE (a_this) && a_pos,
01179 CR_BAD_PARAM_ERROR) ;
01180
01181 cr_input_set_column_num (a_this, a_pos->col) ;
01182 cr_input_set_line_num (a_this, a_pos->line) ;
01183 cr_input_set_cur_index (a_this, a_pos->next_byte_index) ;
01184 cr_input_set_end_of_line (a_this, a_pos->end_of_line) ;
01185 cr_input_set_end_of_file (a_this, a_pos->end_of_file) ;
01186
01187 return CR_OK ;
01188 }