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