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