From patchwork Wed Dec 14 08:48:57 2016 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: Cedric Bosdonnat X-Patchwork-Id: 9473851 Return-Path: Received: from mail.wl.linuxfoundation.org (pdx-wl-mail.web.codeaurora.org [172.30.200.125]) by pdx-korg-patchwork.web.codeaurora.org (Postfix) with ESMTP id 02F9B60571 for ; Wed, 14 Dec 2016 08:52:16 +0000 (UTC) Received: from mail.wl.linuxfoundation.org (localhost [127.0.0.1]) by mail.wl.linuxfoundation.org (Postfix) with ESMTP id E4C24286EF for ; Wed, 14 Dec 2016 08:52:15 +0000 (UTC) Received: by mail.wl.linuxfoundation.org (Postfix, from userid 486) id D833C286F9; Wed, 14 Dec 2016 08:52:15 +0000 (UTC) X-Spam-Checker-Version: SpamAssassin 3.3.1 (2010-03-16) on pdx-wl-mail.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-4.2 required=2.0 tests=BAYES_00, RCVD_IN_DNSWL_MED autolearn=ham version=3.3.1 Received: from lists.xenproject.org (lists.xenproject.org [192.237.175.120]) (using TLSv1.2 with cipher AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by mail.wl.linuxfoundation.org (Postfix) with ESMTPS id 9B1FC286EF for ; Wed, 14 Dec 2016 08:52:13 +0000 (UTC) Received: from localhost ([127.0.0.1] helo=lists.xenproject.org) by lists.xenproject.org with esmtp (Exim 4.84_2) (envelope-from ) id 1cH5FL-0008UE-Fx; Wed, 14 Dec 2016 08:49:07 +0000 Received: from mail6.bemta5.messagelabs.com ([195.245.231.135]) by lists.xenproject.org with esmtp (Exim 4.84_2) (envelope-from ) id 1cH5FK-0008U8-Bf for xen-devel@lists.xen.org; Wed, 14 Dec 2016 08:49:06 +0000 Received: from [85.158.139.211] by server-10.bemta-5.messagelabs.com id D9/9D-21400-18701585; Wed, 14 Dec 2016 08:49:05 +0000 X-Brightmail-Tracker: H4sIAAAAAAAAA+NgFvrNLMWRWlGSWpSXmKPExsVyuP0uq24De2C EwbuZihZLPi5mcWD0OLr7N1MAYxRrZl5SfkUCa8aM5w2MBYu2M1V8fXeIpYFxyj/GLkYuDiGB JYwSG25MZO5i5ORgE7CX6PpzlAnEFhGQlrj2+TJYEbNAO6PEh3vbWEESwgI6EruXzQErYhFQl Vi34y1YnFfAQuLx782MILaEgLzErraLUHFBiZMzn7B0MXIADVKXWD9PCCTMDFTSvHU28wRG7l lIqmYhVM1CUrWAkXkVo0ZxalFZapGuoYFeUlFmekZJbmJmDpBnqpebWlycmJ6ak5hUrJecn7u JERgoDECwg3HNVOdDjJIcTEqivFxXAyKE+JLyUyozEosz4otKc1KLDzHKcHAoSfAGsgVGCAkW paanVqRl5gBDFiYtwcGjJMJrCpLmLS5IzC3OTIdInWJUlBLnnQGSEABJZJTmwbXB4uQSo6yUM C8j0CFCPAWpRbmZJajyrxjFORiVhHk7QKbwZOaVwE1/BbSYCWix6BJ/kMUliQgpqQZGHQ2dW2 s2lX+vTjQreM3h8pfvrR9DKvNMaVGvezJSGjM0j+i7ZjmfahBxfM6aMnFtaMw/jt/JvA2d6k0 CwbciXlex9Fzs/97e9jxU+dyT5v9G0ewRqy2uHpVZ8/OB3uTQF5+dK3X+R38P9S9y01z92Yan 13Hz/OmCKRv3lh+VTppe6LR8h5QSS3FGoqEWc1FxIgD37AlajgIAAA== X-Env-Sender: cbosdonnat@suse.com X-Msg-Ref: server-12.tower-206.messagelabs.com!1481705341!39024759!1 X-Originating-IP: [195.135.221.5] X-SpamReason: No, hits=0.0 required=7.0 tests= X-StarScan-Received: X-StarScan-Version: 9.1.1; banners=-,-,- X-VirusChecked: Checked Received: (qmail 2347 invoked from network); 14 Dec 2016 08:49:01 -0000 Received: from smtp.nue.novell.com (HELO smtp.nue.novell.com) (195.135.221.5) by server-12.tower-206.messagelabs.com with DHE-RSA-AES256-GCM-SHA384 encrypted SMTP; 14 Dec 2016 08:49:01 -0000 Received: from laptop.vms (mhy71-2-88-167-63-197.fbx.proxad.net [88.167.63.197]) by smtp.nue.novell.com with ESMTP (TLS encrypted); Wed, 14 Dec 2016 09:49:01 +0100 From: =?UTF-8?q?C=C3=A9dric=20Bosdonnat?= To: xen-devel@lists.xen.org Date: Wed, 14 Dec 2016 09:48:57 +0100 Message-Id: <20161214084857.31240-1-cbosdonnat@suse.com> X-Mailer: git-send-email 2.11.0 MIME-Version: 1.0 Cc: Wei Liu , Ian Jackson , =?UTF-8?q?C=C3=A9dric=20Bosdonnat?= Subject: [Xen-devel] [PATCH v5] libxl: QED disks support X-BeenThere: xen-devel@lists.xen.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: Xen developer discussion List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Errors-To: xen-devel-bounces@lists.xen.org Sender: "Xen-devel" X-Virus-Scanned: ClamAV using ClamSMTP Qdisk supports qcow and qcow2, extend it to also support qed disk format. Signed-off-by: Cédric Bosdonnat Acked-by: Ian Jackson Acked-by: Wei Liu --- v2: * Add qed to the list for possible format values in xl-disk-configuration.txt * Add LIBXL_HAVE_QED v3: * Remove the qed: obsolete prefix support v4: * Added backing format images in qemu-xen-security doc as requested by Ian v5: * Regenerated libxlu_disk.[ch] --- docs/misc/qemu-xen-security | 1 + docs/misc/xl-disk-configuration.txt | 2 +- tools/libxl/libxl.h | 7 + tools/libxl/libxl_device.c | 1 + tools/libxl/libxl_dm.c | 1 + tools/libxl/libxl_types.idl | 1 + tools/libxl/libxl_utils.c | 2 + tools/libxl/libxlu_disk_l.c | 284 ++++++++++++++++++------------------ tools/libxl/libxlu_disk_l.h | 53 +++---- tools/libxl/libxlu_disk_l.l | 1 + 10 files changed, 179 insertions(+), 174 deletions(-) diff --git a/docs/misc/qemu-xen-security b/docs/misc/qemu-xen-security index 4ab0b4dd26..496f7eee7a 100644 --- a/docs/misc/qemu-xen-security +++ b/docs/misc/qemu-xen-security @@ -4,6 +4,7 @@ a subset of all the possible QEMU emulators. Specifically: - network: e1000, rtl8139, virtio-net - storage: piix3 ide, ahci, xen_disk +- backing storage image format: raw, qcow, qcow2, vhd - graphics: cirris-vga, stdvga and xenfb - audio: sb16, es1370, ac97 - input: Xen PV keyboard and mouse (part of xenfb), USB and PS/2 diff --git a/docs/misc/xl-disk-configuration.txt b/docs/misc/xl-disk-configuration.txt index b3402bc33a..926889b23d 100644 --- a/docs/misc/xl-disk-configuration.txt +++ b/docs/misc/xl-disk-configuration.txt @@ -87,7 +87,7 @@ format ------ Description: Specifies the format of image file. -Supported values: raw, qcow, qcow2, vhd +Supported values: raw, qcow, qcow2, vhd, qed Deprecated values: None Default value: raw diff --git a/tools/libxl/libxl.h b/tools/libxl/libxl.h index acbf47690e..3924464588 100644 --- a/tools/libxl/libxl.h +++ b/tools/libxl/libxl.h @@ -1012,6 +1012,13 @@ void libxl_mac_copy(libxl_ctx *ctx, libxl_mac *dst, const libxl_mac *src); */ #define LIBXL_HAVE_MEMKB_64BITS 1 +/* + * LIBXL_HAVE_QED + * + * If this is defined QED disk formats can be used for both HVM and PV guests. + */ +#define LIBXL_HAVE_QED 1 + typedef char **libxl_string_list; void libxl_string_list_dispose(libxl_string_list *sl); int libxl_string_list_length(const libxl_string_list *sl); diff --git a/tools/libxl/libxl_device.c b/tools/libxl/libxl_device.c index 3e7a1026c4..6c34141072 100644 --- a/tools/libxl/libxl_device.c +++ b/tools/libxl/libxl_device.c @@ -411,6 +411,7 @@ char *libxl__device_disk_string_of_format(libxl_disk_format format) case LIBXL_DISK_FORMAT_VHD: return "vhd"; case LIBXL_DISK_FORMAT_RAW: case LIBXL_DISK_FORMAT_EMPTY: return "aio"; + case LIBXL_DISK_FORMAT_QED: return "qed"; default: return NULL; } } diff --git a/tools/libxl/libxl_dm.c b/tools/libxl/libxl_dm.c index ad366a8cd3..8b373422f1 100644 --- a/tools/libxl/libxl_dm.c +++ b/tools/libxl/libxl_dm.c @@ -677,6 +677,7 @@ static const char *qemu_disk_format_string(libxl_disk_format format) case LIBXL_DISK_FORMAT_VHD: return "vpc"; case LIBXL_DISK_FORMAT_RAW: return "raw"; case LIBXL_DISK_FORMAT_EMPTY: return NULL; + case LIBXL_DISK_FORMAT_QED: return "qed"; default: return NULL; } } diff --git a/tools/libxl/libxl_types.idl b/tools/libxl/libxl_types.idl index a32c751b0e..a612d1f4ff 100644 --- a/tools/libxl/libxl_types.idl +++ b/tools/libxl/libxl_types.idl @@ -114,6 +114,7 @@ libxl_disk_format = Enumeration("disk_format", [ (3, "VHD"), (4, "RAW"), (5, "EMPTY"), + (6, "QED"), ]) libxl_disk_backend = Enumeration("disk_backend", [ diff --git a/tools/libxl/libxl_utils.c b/tools/libxl/libxl_utils.c index 49cbaa5b70..507ee56c7c 100644 --- a/tools/libxl/libxl_utils.c +++ b/tools/libxl/libxl_utils.c @@ -317,6 +317,8 @@ int libxl_string_to_backend(libxl_ctx *ctx, char *s, libxl_disk_backend *backend *backend = LIBXL_DISK_BACKEND_QDISK; } else if (!strcmp(p, "qcow2")) { *backend = LIBXL_DISK_BACKEND_QDISK; + } else if (!strcmp(p, "qed")) { + *backend = LIBXL_DISK_BACKEND_QDISK; } } out: diff --git a/tools/libxl/libxlu_disk_l.c b/tools/libxl/libxlu_disk_l.c index 54160caa66..94ce82bba9 100644 --- a/tools/libxl/libxlu_disk_l.c +++ b/tools/libxl/libxlu_disk_l.c @@ -1,10 +1,7 @@ #line 2 "libxlu_disk_l.c" -#line 31 "libxlu_disk_l.l" #include "libxl_osdeps.h" /* must come before any other headers */ - - -#line 8 "libxlu_disk_l.c" +#line 5 "libxlu_disk_l.c" #define YY_INT_ALIGNED short int @@ -12,8 +9,8 @@ #define FLEX_SCANNER #define YY_FLEX_MAJOR_VERSION 2 -#define YY_FLEX_MINOR_VERSION 5 -#define YY_FLEX_SUBMINOR_VERSION 39 +#define YY_FLEX_MINOR_VERSION 6 +#define YY_FLEX_SUBMINOR_VERSION 1 #if YY_FLEX_SUBMINOR_VERSION > 0 #define FLEX_BETA #endif @@ -92,25 +89,13 @@ typedef unsigned int flex_uint32_t; #endif /* ! FLEXINT_H */ -#ifdef __cplusplus - -/* The "const" storage-class-modifier is valid. */ -#define YY_USE_CONST - -#else /* ! __cplusplus */ - -/* C99 requires __STDC__ to be defined as 1. */ -#if defined (__STDC__) - -#define YY_USE_CONST - -#endif /* defined (__STDC__) */ -#endif /* ! __cplusplus */ - -#ifdef YY_USE_CONST +/* TODO: this is always defined, so inline it */ #define yyconst const + +#if defined(__GNUC__) && __GNUC__ >= 3 +#define yynoreturn __attribute__((__noreturn__)) #else -#define yyconst +#define yynoreturn #endif /* Returned upon end-of-file. */ @@ -223,12 +208,12 @@ struct yy_buffer_state /* Size of input buffer in bytes, not including room for EOB * characters. */ - yy_size_t yy_buf_size; + int yy_buf_size; /* Number of characters read into yy_ch_buf, not including EOB * characters. */ - yy_size_t yy_n_chars; + int yy_n_chars; /* Whether we "own" the buffer - i.e., we know we created it, * and can realloc() it to grow it, and should free() it to @@ -307,7 +292,7 @@ static void xlu__disk_yy_init_buffer (YY_BUFFER_STATE b,FILE *file ,yyscan_t yys YY_BUFFER_STATE xlu__disk_yy_scan_buffer (char *base,yy_size_t size ,yyscan_t yyscanner ); YY_BUFFER_STATE xlu__disk_yy_scan_string (yyconst char *yy_str ,yyscan_t yyscanner ); -YY_BUFFER_STATE xlu__disk_yy_scan_bytes (yyconst char *bytes,yy_size_t len ,yyscan_t yyscanner ); +YY_BUFFER_STATE xlu__disk_yy_scan_bytes (yyconst char *bytes,int len ,yyscan_t yyscanner ); void *xlu__disk_yyalloc (yy_size_t ,yyscan_t yyscanner ); void *xlu__disk_yyrealloc (void *,yy_size_t ,yyscan_t yyscanner ); @@ -337,7 +322,7 @@ void xlu__disk_yyfree (void * ,yyscan_t yyscanner ); #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol) -#define xlu__disk_yywrap(yyscanner) 1 +#define xlu__disk_yywrap(yyscanner) (/*CONSTCOND*/1) #define YY_SKIP_YYWRAP typedef unsigned char YY_CHAR; @@ -349,7 +334,7 @@ typedef int yy_state_type; static yy_state_type yy_get_previous_state (yyscan_t yyscanner ); static yy_state_type yy_try_NUL_trans (yy_state_type current_state ,yyscan_t yyscanner); static int yy_get_next_buffer (yyscan_t yyscanner ); -static void yy_fatal_error (yyconst char msg[] ,yyscan_t yyscanner ); +static void yynoreturn yy_fatal_error (yyconst char* msg ,yyscan_t yyscanner ); /* Done after the current pattern has been matched and before the * corresponding action - sets up yytext. @@ -357,7 +342,7 @@ static void yy_fatal_error (yyconst char msg[] ,yyscan_t yyscanner ); #define YY_DO_BEFORE_ACTION \ yyg->yytext_ptr = yy_bp; \ yyg->yytext_ptr -= yyg->yy_more_len; \ - yyleng = (size_t) (yy_cp - yyg->yytext_ptr); \ + yyleng = (int) (yy_cp - yyg->yytext_ptr); \ yyg->yy_hold_char = *yy_cp; \ *yy_cp = '\0'; \ yyg->yy_c_buf_p = yy_cp; @@ -481,7 +466,7 @@ static yyconst flex_int16_t yy_accept[356] = 570, 571, 573, 575, 575 } ; -static yyconst flex_int32_t yy_ec[256] = +static yyconst YY_CHAR yy_ec[256] = { 0, 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, @@ -513,7 +498,7 @@ static yyconst flex_int32_t yy_ec[256] = 1, 1, 1, 1, 1 } ; -static yyconst flex_int32_t yy_meta[35] = +static yyconst YY_CHAR yy_meta[35] = { 0, 1, 1, 2, 3, 1, 1, 1, 1, 4, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, @@ -521,7 +506,7 @@ static yyconst flex_int32_t yy_meta[35] = 1, 1, 1, 1 } ; -static yyconst flex_int16_t yy_base[424] = +static yyconst flex_uint16_t yy_base[424] = { 0, 0, 0, 901, 900, 902, 897, 33, 36, 905, 905, 45, 63, 31, 42, 51, 52, 890, 33, 65, 67, @@ -623,7 +608,7 @@ static yyconst flex_int16_t yy_def[424] = 354, 354, 354 } ; -static yyconst flex_int16_t yy_nxt[940] = +static yyconst flex_uint16_t yy_nxt[940] = { 0, 6, 7, 8, 9, 6, 6, 6, 6, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 17, 17, @@ -953,6 +938,7 @@ static void setformat(DiskParseContext *dpc, const char *str) { else if (!strcmp(str,"qcow2")) DSET(dpc,format,FORMAT,str,QCOW2); else if (!strcmp(str,"vhd")) DSET(dpc,format,FORMAT,str,VHD); else if (!strcmp(str,"empty")) DSET(dpc,format,FORMAT,str,EMPTY); + else if (!strcmp(str,"qed")) DSET(dpc,format,FORMAT,str,QED); else xlu__disk_err(dpc,str,"unknown value for format"); } @@ -1001,7 +987,7 @@ static int vdev_and_devtype(DiskParseContext *dpc, char *str) { #define DPC ((DiskParseContext*)yyextra) -#line 1005 "libxlu_disk_l.c" +#line 991 "libxlu_disk_l.c" #define INITIAL 0 #define LEXERR 1 @@ -1031,8 +1017,8 @@ struct yyguts_t size_t yy_buffer_stack_max; /**< capacity of stack. */ YY_BUFFER_STATE * yy_buffer_stack; /**< Stack as an array. */ char yy_hold_char; - yy_size_t yy_n_chars; - yy_size_t yyleng_r; + int yy_n_chars; + int yyleng_r; char *yy_c_buf_p; int yy_init; int yy_start; @@ -1084,23 +1070,23 @@ void xlu__disk_yyset_extra (YY_EXTRA_TYPE user_defined ,yyscan_t yyscanner ); FILE *xlu__disk_yyget_in (yyscan_t yyscanner ); -void xlu__disk_yyset_in (FILE * in_str ,yyscan_t yyscanner ); +void xlu__disk_yyset_in (FILE * _in_str ,yyscan_t yyscanner ); FILE *xlu__disk_yyget_out (yyscan_t yyscanner ); -void xlu__disk_yyset_out (FILE * out_str ,yyscan_t yyscanner ); +void xlu__disk_yyset_out (FILE * _out_str ,yyscan_t yyscanner ); -yy_size_t xlu__disk_yyget_leng (yyscan_t yyscanner ); + int xlu__disk_yyget_leng (yyscan_t yyscanner ); char *xlu__disk_yyget_text (yyscan_t yyscanner ); int xlu__disk_yyget_lineno (yyscan_t yyscanner ); -void xlu__disk_yyset_lineno (int line_number ,yyscan_t yyscanner ); +void xlu__disk_yyset_lineno (int _line_number ,yyscan_t yyscanner ); int xlu__disk_yyget_column (yyscan_t yyscanner ); -void xlu__disk_yyset_column (int column_no ,yyscan_t yyscanner ); +void xlu__disk_yyset_column (int _column_no ,yyscan_t yyscanner ); /* Macros after this point can all be overridden by user definitions in * section 1. @@ -1114,6 +1100,10 @@ extern int xlu__disk_yywrap (yyscan_t yyscanner ); #endif #endif +#ifndef YY_NO_UNPUT + +#endif + #ifndef yytext_ptr static void yy_flex_strncpy (char *,yyconst char *,int ,yyscan_t yyscanner); #endif @@ -1147,7 +1137,7 @@ static int input (yyscan_t yyscanner ); /* This used to be an fputs(), but since the string might contain NUL's, * we now use fwrite(). */ -#define ECHO do { if (fwrite( yytext, yyleng, 1, yyout )) {} } while (0) +#define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0) #endif /* Gets input and stuffs it into "buf". number of characters read, or YY_NULL, @@ -1158,7 +1148,7 @@ static int input (yyscan_t yyscanner ); if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \ { \ int c = '*'; \ - int n; \ + size_t n; \ for ( n = 0; n < max_size && \ (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ buf[n] = (char) c; \ @@ -1171,7 +1161,7 @@ static int input (yyscan_t yyscanner ); else \ { \ errno=0; \ - while ( (result = fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \ + while ( (result = (int) fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \ { \ if( errno != EINTR) \ { \ @@ -1226,7 +1216,7 @@ extern int xlu__disk_yylex (yyscan_t yyscanner); /* Code executed at the end of each rule. */ #ifndef YY_BREAK -#define YY_BREAK break; +#define YY_BREAK /*LINTED*/break; #endif #define YY_RULE_SETUP \ @@ -1236,9 +1226,9 @@ extern int xlu__disk_yylex (yyscan_t yyscanner); */ YY_DECL { - register yy_state_type yy_current_state; - register char *yy_cp, *yy_bp; - register int yy_act; + yy_state_type yy_current_state; + char *yy_cp, *yy_bp; + int yy_act; struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; if ( !yyg->yy_init ) @@ -1274,14 +1264,14 @@ YY_DECL } { -#line 165 "libxlu_disk_l.l" +#line 166 "libxlu_disk_l.l" /*----- the scanner rules which do the parsing -----*/ -#line 1283 "libxlu_disk_l.c" +#line 1273 "libxlu_disk_l.c" - while ( 1 ) /* loops until end-of-file is reached */ + while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */ { yyg->yy_more_len = 0; if ( yyg->yy_more_flag ) @@ -1307,14 +1297,14 @@ YY_DECL yy_match: do { - register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ; + YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ; while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) { yy_current_state = (int) yy_def[yy_current_state]; if ( yy_current_state >= 355 ) yy_c = yy_meta[(unsigned int) yy_c]; } - yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; + yy_current_state = yy_nxt[yy_base[yy_current_state] + (flex_int16_t) yy_c]; *yyg->yy_state_ptr++ = yy_current_state; ++yy_cp; } @@ -1368,135 +1358,135 @@ do_action: /* This label is used only to access EOF actions. */ case 1: /* rule 1 can match eol */ YY_RULE_SETUP -#line 169 "libxlu_disk_l.l" +#line 170 "libxlu_disk_l.l" { /* ignore whitespace before parameters */ } YY_BREAK /* ordinary parameters setting enums or strings */ case 2: /* rule 2 can match eol */ YY_RULE_SETUP -#line 173 "libxlu_disk_l.l" +#line 174 "libxlu_disk_l.l" { STRIP(','); setformat(DPC, FROMEQUALS); } YY_BREAK case 3: YY_RULE_SETUP -#line 175 "libxlu_disk_l.l" +#line 176 "libxlu_disk_l.l" { DPC->disk->is_cdrom = 1; } YY_BREAK case 4: YY_RULE_SETUP -#line 176 "libxlu_disk_l.l" +#line 177 "libxlu_disk_l.l" { DPC->disk->is_cdrom = 1; } YY_BREAK case 5: YY_RULE_SETUP -#line 177 "libxlu_disk_l.l" +#line 178 "libxlu_disk_l.l" { DPC->disk->is_cdrom = 0; } YY_BREAK case 6: /* rule 6 can match eol */ YY_RULE_SETUP -#line 178 "libxlu_disk_l.l" +#line 179 "libxlu_disk_l.l" { xlu__disk_err(DPC,yytext,"unknown value for type"); } YY_BREAK case 7: /* rule 7 can match eol */ YY_RULE_SETUP -#line 180 "libxlu_disk_l.l" +#line 181 "libxlu_disk_l.l" { STRIP(','); setaccess(DPC, FROMEQUALS); } YY_BREAK case 8: /* rule 8 can match eol */ YY_RULE_SETUP -#line 181 "libxlu_disk_l.l" +#line 182 "libxlu_disk_l.l" { STRIP(','); SAVESTRING("backend", backend_domname, FROMEQUALS); } YY_BREAK case 9: /* rule 9 can match eol */ YY_RULE_SETUP -#line 182 "libxlu_disk_l.l" +#line 183 "libxlu_disk_l.l" { STRIP(','); setbackendtype(DPC,FROMEQUALS); } YY_BREAK case 10: /* rule 10 can match eol */ YY_RULE_SETUP -#line 184 "libxlu_disk_l.l" +#line 185 "libxlu_disk_l.l" { STRIP(','); SAVESTRING("vdev", vdev, FROMEQUALS); } YY_BREAK case 11: /* rule 11 can match eol */ YY_RULE_SETUP -#line 185 "libxlu_disk_l.l" +#line 186 "libxlu_disk_l.l" { STRIP(','); SAVESTRING("script", script, FROMEQUALS); } YY_BREAK case 12: YY_RULE_SETUP -#line 186 "libxlu_disk_l.l" +#line 187 "libxlu_disk_l.l" { DPC->disk->direct_io_safe = 1; } YY_BREAK case 13: YY_RULE_SETUP -#line 187 "libxlu_disk_l.l" +#line 188 "libxlu_disk_l.l" { libxl_defbool_set(&DPC->disk->discard_enable, true); } YY_BREAK case 14: YY_RULE_SETUP -#line 188 "libxlu_disk_l.l" +#line 189 "libxlu_disk_l.l" { libxl_defbool_set(&DPC->disk->discard_enable, false); } YY_BREAK /* Note that the COLO configuration settings should be considered unstable. * They may change incompatibly in future versions of Xen. */ case 15: YY_RULE_SETUP -#line 191 "libxlu_disk_l.l" +#line 192 "libxlu_disk_l.l" { libxl_defbool_set(&DPC->disk->colo_enable, true); } YY_BREAK case 16: YY_RULE_SETUP -#line 192 "libxlu_disk_l.l" +#line 193 "libxlu_disk_l.l" { libxl_defbool_set(&DPC->disk->colo_enable, false); } YY_BREAK case 17: /* rule 17 can match eol */ YY_RULE_SETUP -#line 193 "libxlu_disk_l.l" +#line 194 "libxlu_disk_l.l" { STRIP(','); SAVESTRING("colo-host", colo_host, FROMEQUALS); } YY_BREAK case 18: /* rule 18 can match eol */ YY_RULE_SETUP -#line 194 "libxlu_disk_l.l" +#line 195 "libxlu_disk_l.l" { STRIP(','); setcoloport(DPC, FROMEQUALS); } YY_BREAK case 19: /* rule 19 can match eol */ YY_RULE_SETUP -#line 195 "libxlu_disk_l.l" +#line 196 "libxlu_disk_l.l" { STRIP(','); SAVESTRING("colo-export", colo_export, FROMEQUALS); } YY_BREAK case 20: /* rule 20 can match eol */ YY_RULE_SETUP -#line 196 "libxlu_disk_l.l" +#line 197 "libxlu_disk_l.l" { STRIP(','); SAVESTRING("active-disk", active_disk, FROMEQUALS); } YY_BREAK case 21: /* rule 21 can match eol */ YY_RULE_SETUP -#line 197 "libxlu_disk_l.l" +#line 198 "libxlu_disk_l.l" { STRIP(','); SAVESTRING("hidden-disk", hidden_disk, FROMEQUALS); } YY_BREAK /* the target magic parameter, eats the rest of the string */ case 22: YY_RULE_SETUP -#line 201 "libxlu_disk_l.l" +#line 202 "libxlu_disk_l.l" { STRIP(','); SAVESTRING("target", pdev_path, FROMEQUALS); } YY_BREAK /* unknown parameters */ case 23: /* rule 23 can match eol */ YY_RULE_SETUP -#line 205 "libxlu_disk_l.l" +#line 206 "libxlu_disk_l.l" { xlu__disk_err(DPC,yytext,"unknown parameter"); } YY_BREAK /* deprecated prefixes */ @@ -1504,7 +1494,7 @@ YY_RULE_SETUP * matched the whole string, so these patterns take precedence */ case 24: YY_RULE_SETUP -#line 212 "libxlu_disk_l.l" +#line 213 "libxlu_disk_l.l" { STRIP(':'); DPC->had_depr_prefix=1; DEPRECATE("use `[format=]...,'"); @@ -1513,7 +1503,7 @@ YY_RULE_SETUP YY_BREAK case 25: YY_RULE_SETUP -#line 218 "libxlu_disk_l.l" +#line 219 "libxlu_disk_l.l" { char *newscript; STRIP(':'); @@ -1532,12 +1522,12 @@ case 26: yyg->yy_c_buf_p = yy_cp = yy_bp + 8; YY_DO_BEFORE_ACTION; /* set up yytext again */ YY_RULE_SETUP -#line 231 "libxlu_disk_l.l" +#line 232 "libxlu_disk_l.l" { DPC->had_depr_prefix=1; DEPRECATE(0); } YY_BREAK case 27: YY_RULE_SETUP -#line 232 "libxlu_disk_l.l" +#line 233 "libxlu_disk_l.l" { DPC->had_depr_prefix=1; DEPRECATE(0); } YY_BREAK case 28: @@ -1545,7 +1535,7 @@ case 28: yyg->yy_c_buf_p = yy_cp = yy_bp + 4; YY_DO_BEFORE_ACTION; /* set up yytext again */ YY_RULE_SETUP -#line 233 "libxlu_disk_l.l" +#line 234 "libxlu_disk_l.l" { DPC->had_depr_prefix=1; DEPRECATE(0); } YY_BREAK case 29: @@ -1553,7 +1543,7 @@ case 29: yyg->yy_c_buf_p = yy_cp = yy_bp + 6; YY_DO_BEFORE_ACTION; /* set up yytext again */ YY_RULE_SETUP -#line 234 "libxlu_disk_l.l" +#line 235 "libxlu_disk_l.l" { DPC->had_depr_prefix=1; DEPRECATE(0); } YY_BREAK case 30: @@ -1561,7 +1551,7 @@ case 30: yyg->yy_c_buf_p = yy_cp = yy_bp + 5; YY_DO_BEFORE_ACTION; /* set up yytext again */ YY_RULE_SETUP -#line 235 "libxlu_disk_l.l" +#line 236 "libxlu_disk_l.l" { DPC->had_depr_prefix=1; DEPRECATE(0); } YY_BREAK case 31: @@ -1569,13 +1559,13 @@ case 31: yyg->yy_c_buf_p = yy_cp = yy_bp + 4; YY_DO_BEFORE_ACTION; /* set up yytext again */ YY_RULE_SETUP -#line 236 "libxlu_disk_l.l" +#line 237 "libxlu_disk_l.l" { DPC->had_depr_prefix=1; DEPRECATE(0); } YY_BREAK case 32: /* rule 32 can match eol */ YY_RULE_SETUP -#line 238 "libxlu_disk_l.l" +#line 239 "libxlu_disk_l.l" { xlu__disk_err(DPC,yytext,"unknown deprecated disk prefix"); return 0; @@ -1585,7 +1575,7 @@ YY_RULE_SETUP case 33: /* rule 33 can match eol */ YY_RULE_SETUP -#line 245 "libxlu_disk_l.l" +#line 246 "libxlu_disk_l.l" { STRIP(','); @@ -1614,7 +1604,7 @@ YY_RULE_SETUP YY_BREAK case 34: YY_RULE_SETUP -#line 271 "libxlu_disk_l.l" +#line 272 "libxlu_disk_l.l" { BEGIN(LEXERR); yymore(); @@ -1622,17 +1612,17 @@ YY_RULE_SETUP YY_BREAK case 35: YY_RULE_SETUP -#line 275 "libxlu_disk_l.l" +#line 276 "libxlu_disk_l.l" { xlu__disk_err(DPC,yytext,"bad disk syntax"); return 0; } YY_BREAK case 36: YY_RULE_SETUP -#line 278 "libxlu_disk_l.l" +#line 279 "libxlu_disk_l.l" YY_FATAL_ERROR( "flex scanner jammed" ); YY_BREAK -#line 1636 "libxlu_disk_l.c" +#line 1626 "libxlu_disk_l.c" case YY_STATE_EOF(INITIAL): case YY_STATE_EOF(LEXERR): yyterminate(); @@ -1777,9 +1767,9 @@ YY_FATAL_ERROR( "flex scanner jammed" ); static int yy_get_next_buffer (yyscan_t yyscanner) { struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; - register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf; - register char *source = yyg->yytext_ptr; - register int number_to_move, i; + char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf; + char *source = yyg->yytext_ptr; + yy_size_t number_to_move, i; int ret_val; if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] ) @@ -1808,7 +1798,7 @@ static int yy_get_next_buffer (yyscan_t yyscanner) /* Try to read more data. */ /* First move last chars to start of buffer. */ - number_to_move = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr) - 1; + number_to_move = (yy_size_t) (yyg->yy_c_buf_p - yyg->yytext_ptr) - 1; for ( i = 0; i < number_to_move; ++i ) *(dest++) = *(source++); @@ -1861,9 +1851,9 @@ static int yy_get_next_buffer (yyscan_t yyscanner) else ret_val = EOB_ACT_CONTINUE_SCAN; - if ((yy_size_t) (yyg->yy_n_chars + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) { + if ((int) (yyg->yy_n_chars + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) { /* Extend the array by 50%, plus the number we really need. */ - yy_size_t new_size = yyg->yy_n_chars + number_to_move + (yyg->yy_n_chars >> 1); + int new_size = yyg->yy_n_chars + number_to_move + (yyg->yy_n_chars >> 1); YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) xlu__disk_yyrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size ,yyscanner ); if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" ); @@ -1882,8 +1872,8 @@ static int yy_get_next_buffer (yyscan_t yyscanner) static yy_state_type yy_get_previous_state (yyscan_t yyscanner) { - register yy_state_type yy_current_state; - register char *yy_cp; + yy_state_type yy_current_state; + char *yy_cp; struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; yy_current_state = yyg->yy_start; @@ -1893,14 +1883,14 @@ static int yy_get_next_buffer (yyscan_t yyscanner) for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp ) { - register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); + YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) { yy_current_state = (int) yy_def[yy_current_state]; if ( yy_current_state >= 355 ) yy_c = yy_meta[(unsigned int) yy_c]; } - yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; + yy_current_state = yy_nxt[yy_base[yy_current_state] + (flex_int16_t) yy_c]; *yyg->yy_state_ptr++ = yy_current_state; } @@ -1914,17 +1904,17 @@ static int yy_get_next_buffer (yyscan_t yyscanner) */ static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state , yyscan_t yyscanner) { - register int yy_is_jam; + int yy_is_jam; struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; /* This var may be unused depending upon options. */ - register YY_CHAR yy_c = 1; + YY_CHAR yy_c = 1; while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) { yy_current_state = (int) yy_def[yy_current_state]; if ( yy_current_state >= 355 ) yy_c = yy_meta[(unsigned int) yy_c]; } - yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; + yy_current_state = yy_nxt[yy_base[yy_current_state] + (flex_int16_t) yy_c]; yy_is_jam = (yy_current_state == 354); if ( ! yy_is_jam ) *yyg->yy_state_ptr++ = yy_current_state; @@ -1933,6 +1923,10 @@ static int yy_get_next_buffer (yyscan_t yyscanner) return yy_is_jam ? 0 : yy_current_state; } +#ifndef YY_NO_UNPUT + +#endif + #ifndef YY_NO_INPUT #ifdef __cplusplus static int yyinput (yyscan_t yyscanner) @@ -1958,7 +1952,7 @@ static int yy_get_next_buffer (yyscan_t yyscanner) else { /* need more input */ - yy_size_t offset = yyg->yy_c_buf_p - yyg->yytext_ptr; + int offset = yyg->yy_c_buf_p - yyg->yytext_ptr; ++yyg->yy_c_buf_p; switch ( yy_get_next_buffer( yyscanner ) ) @@ -1982,7 +1976,7 @@ static int yy_get_next_buffer (yyscan_t yyscanner) case EOB_ACT_END_OF_FILE: { if ( xlu__disk_yywrap(yyscanner ) ) - return EOF; + return 0; if ( ! yyg->yy_did_buffer_switch_on_eof ) YY_NEW_FILE; @@ -2086,7 +2080,7 @@ static void xlu__disk_yy_load_buffer_state (yyscan_t yyscanner) if ( ! b ) YY_FATAL_ERROR( "out of dynamic memory in xlu__disk_yy_create_buffer()" ); - b->yy_buf_size = size; + b->yy_buf_size = (yy_size_t)size; /* yy_ch_buf has to be 2 characters longer than the size given because * we need to put in 2 end-of-buffer characters. @@ -2238,7 +2232,7 @@ void xlu__disk_yypop_buffer_state (yyscan_t yyscanner) */ static void xlu__disk_yyensure_buffer_stack (yyscan_t yyscanner) { - yy_size_t num_to_alloc; + int num_to_alloc; struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; if (!yyg->yy_buffer_stack) { @@ -2247,7 +2241,7 @@ static void xlu__disk_yyensure_buffer_stack (yyscan_t yyscanner) * scanner will even need a stack. We use 2 instead of 1 to avoid an * immediate realloc on the next call. */ - num_to_alloc = 1; + num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */ yyg->yy_buffer_stack = (struct yy_buffer_state**)xlu__disk_yyalloc (num_to_alloc * sizeof(struct yy_buffer_state*) , yyscanner); @@ -2264,7 +2258,7 @@ static void xlu__disk_yyensure_buffer_stack (yyscan_t yyscanner) if (yyg->yy_buffer_stack_top >= (yyg->yy_buffer_stack_max) - 1){ /* Increase the buffer to prepare for a possible push. */ - int grow_size = 8 /* arbitrary grow size */; + yy_size_t grow_size = 8 /* arbitrary grow size */; num_to_alloc = yyg->yy_buffer_stack_max + grow_size; yyg->yy_buffer_stack = (struct yy_buffer_state**)xlu__disk_yyrealloc @@ -2294,7 +2288,7 @@ YY_BUFFER_STATE xlu__disk_yy_scan_buffer (char * base, yy_size_t size , yyscan base[size-2] != YY_END_OF_BUFFER_CHAR || base[size-1] != YY_END_OF_BUFFER_CHAR ) /* They forgot to leave room for the EOB's. */ - return 0; + return NULL; b = (YY_BUFFER_STATE) xlu__disk_yyalloc(sizeof( struct yy_buffer_state ) ,yyscanner ); if ( ! b ) @@ -2303,7 +2297,7 @@ YY_BUFFER_STATE xlu__disk_yy_scan_buffer (char * base, yy_size_t size , yyscan b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */ b->yy_buf_pos = b->yy_ch_buf = base; b->yy_is_our_buffer = 0; - b->yy_input_file = 0; + b->yy_input_file = NULL; b->yy_n_chars = b->yy_buf_size; b->yy_is_interactive = 0; b->yy_at_bol = 1; @@ -2326,7 +2320,7 @@ YY_BUFFER_STATE xlu__disk_yy_scan_buffer (char * base, yy_size_t size , yyscan YY_BUFFER_STATE xlu__disk_yy_scan_string (yyconst char * yystr , yyscan_t yyscanner) { - return xlu__disk_yy_scan_bytes(yystr,strlen(yystr) ,yyscanner); + return xlu__disk_yy_scan_bytes(yystr,(int) strlen(yystr) ,yyscanner); } /** Setup the input buffer state to scan the given bytes. The next call to xlu__disk_yylex() will @@ -2336,7 +2330,7 @@ YY_BUFFER_STATE xlu__disk_yy_scan_string (yyconst char * yystr , yyscan_t yyscan * @param yyscanner The scanner object. * @return the newly allocated buffer state object. */ -YY_BUFFER_STATE xlu__disk_yy_scan_bytes (yyconst char * yybytes, yy_size_t _yybytes_len , yyscan_t yyscanner) +YY_BUFFER_STATE xlu__disk_yy_scan_bytes (yyconst char * yybytes, int _yybytes_len , yyscan_t yyscanner) { YY_BUFFER_STATE b; char *buf; @@ -2344,7 +2338,7 @@ YY_BUFFER_STATE xlu__disk_yy_scan_bytes (yyconst char * yybytes, yy_size_t _yy yy_size_t i; /* Get memory for full buffer, including space for trailing EOB's. */ - n = _yybytes_len + 2; + n = (yy_size_t) _yybytes_len + 2; buf = (char *) xlu__disk_yyalloc(n ,yyscanner ); if ( ! buf ) YY_FATAL_ERROR( "out of dynamic memory in xlu__disk_yy_scan_bytes()" ); @@ -2370,9 +2364,11 @@ YY_BUFFER_STATE xlu__disk_yy_scan_bytes (yyconst char * yybytes, yy_size_t _yy #define YY_EXIT_FAILURE 2 #endif -static void yy_fatal_error (yyconst char* msg , yyscan_t yyscanner) +static void yynoreturn yy_fatal_error (yyconst char* msg , yyscan_t yyscanner) { - (void) fprintf( stderr, "%s\n", msg ); + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + (void)yyg; + (void) fprintf( stderr, "%s\n", msg ); exit( YY_EXIT_FAILURE ); } @@ -2451,7 +2447,7 @@ FILE *xlu__disk_yyget_out (yyscan_t yyscanner) /** Get the length of the current token. * @param yyscanner The scanner object. */ -yy_size_t xlu__disk_yyget_leng (yyscan_t yyscanner) +int xlu__disk_yyget_leng (yyscan_t yyscanner) { struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; return yyleng; @@ -2478,10 +2474,10 @@ void xlu__disk_yyset_extra (YY_EXTRA_TYPE user_defined , yyscan_t yyscanner) } /** Set the current line number. - * @param line_number + * @param _line_number line number * @param yyscanner The scanner object. */ -void xlu__disk_yyset_lineno (int line_number , yyscan_t yyscanner) +void xlu__disk_yyset_lineno (int _line_number , yyscan_t yyscanner) { struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; @@ -2489,14 +2485,14 @@ void xlu__disk_yyset_lineno (int line_number , yyscan_t yyscanner) if (! YY_CURRENT_BUFFER ) YY_FATAL_ERROR( "xlu__disk_yyset_lineno called with no buffer" ); - yylineno = line_number; + yylineno = _line_number; } /** Set the current column. - * @param line_number + * @param _column_no column number * @param yyscanner The scanner object. */ -void xlu__disk_yyset_column (int column_no , yyscan_t yyscanner) +void xlu__disk_yyset_column (int _column_no , yyscan_t yyscanner) { struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; @@ -2504,25 +2500,25 @@ void xlu__disk_yyset_column (int column_no , yyscan_t yyscanner) if (! YY_CURRENT_BUFFER ) YY_FATAL_ERROR( "xlu__disk_yyset_column called with no buffer" ); - yycolumn = column_no; + yycolumn = _column_no; } /** Set the input stream. This does not discard the current * input buffer. - * @param in_str A readable stream. + * @param _in_str A readable stream. * @param yyscanner The scanner object. * @see xlu__disk_yy_switch_to_buffer */ -void xlu__disk_yyset_in (FILE * in_str , yyscan_t yyscanner) +void xlu__disk_yyset_in (FILE * _in_str , yyscan_t yyscanner) { struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; - yyin = in_str ; + yyin = _in_str ; } -void xlu__disk_yyset_out (FILE * out_str , yyscan_t yyscanner) +void xlu__disk_yyset_out (FILE * _out_str , yyscan_t yyscanner) { struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; - yyout = out_str ; + yyout = _out_str ; } int xlu__disk_yyget_debug (yyscan_t yyscanner) @@ -2531,10 +2527,10 @@ int xlu__disk_yyget_debug (yyscan_t yyscanner) return yy_flex_debug; } -void xlu__disk_yyset_debug (int bdebug , yyscan_t yyscanner) +void xlu__disk_yyset_debug (int _bdebug , yyscan_t yyscanner) { struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; - yy_flex_debug = bdebug ; + yy_flex_debug = _bdebug ; } /* Accessor methods for yylval and yylloc */ @@ -2610,10 +2606,10 @@ static int yy_init_globals (yyscan_t yyscanner) * This function is called from xlu__disk_yylex_destroy(), so don't allocate here. */ - yyg->yy_buffer_stack = 0; + yyg->yy_buffer_stack = NULL; yyg->yy_buffer_stack_top = 0; yyg->yy_buffer_stack_max = 0; - yyg->yy_c_buf_p = (char *) 0; + yyg->yy_c_buf_p = NULL; yyg->yy_init = 0; yyg->yy_start = 0; @@ -2631,8 +2627,8 @@ static int yy_init_globals (yyscan_t yyscanner) yyin = stdin; yyout = stdout; #else - yyin = (FILE *) 0; - yyout = (FILE *) 0; + yyin = NULL; + yyout = NULL; #endif /* For future reference: Set errno on error, since we are called by @@ -2681,7 +2677,10 @@ int xlu__disk_yylex_destroy (yyscan_t yyscanner) #ifndef yytext_ptr static void yy_flex_strncpy (char* s1, yyconst char * s2, int n , yyscan_t yyscanner) { - register int i; + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + (void)yyg; + + int i; for ( i = 0; i < n; ++i ) s1[i] = s2[i]; } @@ -2690,7 +2689,7 @@ static void yy_flex_strncpy (char* s1, yyconst char * s2, int n , yyscan_t yysca #ifdef YY_NEED_STRLEN static int yy_flex_strlen (yyconst char * s , yyscan_t yyscanner) { - register int n; + int n; for ( n = 0; s[n]; ++n ) ; @@ -2700,11 +2699,16 @@ static int yy_flex_strlen (yyconst char * s , yyscan_t yyscanner) void *xlu__disk_yyalloc (yy_size_t size , yyscan_t yyscanner) { - return (void *) malloc( size ); + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + (void)yyg; + return malloc(size); } void *xlu__disk_yyrealloc (void * ptr, yy_size_t size , yyscan_t yyscanner) { + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + (void)yyg; + /* The cast to (char *) in the following accommodates both * implementations that use char* generic pointers, and those * that use void* generic pointers. It works with the latter @@ -2712,14 +2716,16 @@ void *xlu__disk_yyrealloc (void * ptr, yy_size_t size , yyscan_t yyscanner) * any pointer type to void*, and deal with argument conversions * as though doing an assignment. */ - return (void *) realloc( (char *) ptr, size ); + return realloc(ptr, size); } void xlu__disk_yyfree (void * ptr , yyscan_t yyscanner) { + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + (void)yyg; free( (char *) ptr ); /* see xlu__disk_yyrealloc() for (char *) cast */ } #define YYTABLES_NAME "yytables" -#line 277 "libxlu_disk_l.l" +#line 279 "libxlu_disk_l.l" diff --git a/tools/libxl/libxlu_disk_l.h b/tools/libxl/libxlu_disk_l.h index 794274f552..abeb9bdd68 100644 --- a/tools/libxl/libxlu_disk_l.h +++ b/tools/libxl/libxlu_disk_l.h @@ -3,12 +3,9 @@ #define xlu__disk_yyIN_HEADER 1 #line 6 "libxlu_disk_l.h" -#line 31 "libxlu_disk_l.l" #include "libxl_osdeps.h" /* must come before any other headers */ - - -#line 12 "libxlu_disk_l.h" +#line 9 "libxlu_disk_l.h" #define YY_INT_ALIGNED short int @@ -16,8 +13,8 @@ #define FLEX_SCANNER #define YY_FLEX_MAJOR_VERSION 2 -#define YY_FLEX_MINOR_VERSION 5 -#define YY_FLEX_SUBMINOR_VERSION 39 +#define YY_FLEX_MINOR_VERSION 6 +#define YY_FLEX_SUBMINOR_VERSION 1 #if YY_FLEX_SUBMINOR_VERSION > 0 #define FLEX_BETA #endif @@ -96,25 +93,13 @@ typedef unsigned int flex_uint32_t; #endif /* ! FLEXINT_H */ -#ifdef __cplusplus - -/* The "const" storage-class-modifier is valid. */ -#define YY_USE_CONST - -#else /* ! __cplusplus */ - -/* C99 requires __STDC__ to be defined as 1. */ -#if defined (__STDC__) - -#define YY_USE_CONST - -#endif /* defined (__STDC__) */ -#endif /* ! __cplusplus */ - -#ifdef YY_USE_CONST +/* TODO: this is always defined, so inline it */ #define yyconst const + +#if defined(__GNUC__) && __GNUC__ >= 3 +#define yynoreturn __attribute__((__noreturn__)) #else -#define yyconst +#define yynoreturn #endif /* An opaque pointer. */ @@ -169,12 +154,12 @@ struct yy_buffer_state /* Size of input buffer in bytes, not including room for EOB * characters. */ - yy_size_t yy_buf_size; + int yy_buf_size; /* Number of characters read into yy_ch_buf, not including EOB * characters. */ - yy_size_t yy_n_chars; + int yy_n_chars; /* Whether we "own" the buffer - i.e., we know we created it, * and can realloc() it to grow it, and should free() it to @@ -218,13 +203,13 @@ void xlu__disk_yypop_buffer_state (yyscan_t yyscanner ); YY_BUFFER_STATE xlu__disk_yy_scan_buffer (char *base,yy_size_t size ,yyscan_t yyscanner ); YY_BUFFER_STATE xlu__disk_yy_scan_string (yyconst char *yy_str ,yyscan_t yyscanner ); -YY_BUFFER_STATE xlu__disk_yy_scan_bytes (yyconst char *bytes,yy_size_t len ,yyscan_t yyscanner ); +YY_BUFFER_STATE xlu__disk_yy_scan_bytes (yyconst char *bytes,int len ,yyscan_t yyscanner ); void *xlu__disk_yyalloc (yy_size_t ,yyscan_t yyscanner ); void *xlu__disk_yyrealloc (void *,yy_size_t ,yyscan_t yyscanner ); void xlu__disk_yyfree (void * ,yyscan_t yyscanner ); -#define xlu__disk_yywrap(yyscanner) 1 +#define xlu__disk_yywrap(yyscanner) (/*CONSTCOND*/1) #define YY_SKIP_YYWRAP #define yytext_ptr yytext_r @@ -266,23 +251,23 @@ void xlu__disk_yyset_extra (YY_EXTRA_TYPE user_defined ,yyscan_t yyscanner ); FILE *xlu__disk_yyget_in (yyscan_t yyscanner ); -void xlu__disk_yyset_in (FILE * in_str ,yyscan_t yyscanner ); +void xlu__disk_yyset_in (FILE * _in_str ,yyscan_t yyscanner ); FILE *xlu__disk_yyget_out (yyscan_t yyscanner ); -void xlu__disk_yyset_out (FILE * out_str ,yyscan_t yyscanner ); +void xlu__disk_yyset_out (FILE * _out_str ,yyscan_t yyscanner ); -yy_size_t xlu__disk_yyget_leng (yyscan_t yyscanner ); + int xlu__disk_yyget_leng (yyscan_t yyscanner ); char *xlu__disk_yyget_text (yyscan_t yyscanner ); int xlu__disk_yyget_lineno (yyscan_t yyscanner ); -void xlu__disk_yyset_lineno (int line_number ,yyscan_t yyscanner ); +void xlu__disk_yyset_lineno (int _line_number ,yyscan_t yyscanner ); int xlu__disk_yyget_column (yyscan_t yyscanner ); -void xlu__disk_yyset_column (int column_no ,yyscan_t yyscanner ); +void xlu__disk_yyset_column (int _column_no ,yyscan_t yyscanner ); /* Macros after this point can all be overridden by user definitions in * section 1. @@ -348,8 +333,8 @@ extern int xlu__disk_yylex (yyscan_t yyscanner); #undef YY_DECL #endif -#line 277 "libxlu_disk_l.l" +#line 279 "libxlu_disk_l.l" -#line 354 "libxlu_disk_l.h" +#line 339 "libxlu_disk_l.h" #undef xlu__disk_yyIN_HEADER #endif /* xlu__disk_yyHEADER_H */ diff --git a/tools/libxl/libxlu_disk_l.l b/tools/libxl/libxlu_disk_l.l index 5b6db221e4..97039a2800 100644 --- a/tools/libxl/libxlu_disk_l.l +++ b/tools/libxl/libxlu_disk_l.l @@ -102,6 +102,7 @@ static void setformat(DiskParseContext *dpc, const char *str) { else if (!strcmp(str,"qcow2")) DSET(dpc,format,FORMAT,str,QCOW2); else if (!strcmp(str,"vhd")) DSET(dpc,format,FORMAT,str,VHD); else if (!strcmp(str,"empty")) DSET(dpc,format,FORMAT,str,EMPTY); + else if (!strcmp(str,"qed")) DSET(dpc,format,FORMAT,str,QED); else xlu__disk_err(dpc,str,"unknown value for format"); }