aboutsummaryrefslogtreecommitdiffstats
path: root/test/racc/assets/mof.y
diff options
context:
space:
mode:
Diffstat (limited to 'test/racc/assets/mof.y')
-rw-r--r--test/racc/assets/mof.y649
1 files changed, 649 insertions, 0 deletions
diff --git a/test/racc/assets/mof.y b/test/racc/assets/mof.y
new file mode 100644
index 0000000000..1adc5ade14
--- /dev/null
+++ b/test/racc/assets/mof.y
@@ -0,0 +1,649 @@
+# Distributed under the Ruby license
+# See http://www.ruby-lang.org/en/LICENSE.txt for the full license text
+# Copyright (c) 2010 Klaus Kämpf <kkaempf@suse.de>
+
+/*
+ * According to appendix A of
+ * http://www.dmtf.org/standards/cim/cim_spec_v22
+ */
+
+class MOF::Parser
+ prechigh
+/* nonassoc UMINUS */
+ left '*' '/'
+ left '+' '-'
+ preclow
+
+ token PRAGMA INCLUDE IDENTIFIER CLASS ASSOCIATION INDICATION
+ AMENDED ENABLEOVERRIDE DISABLEOVERRIDE RESTRICTED TOSUBCLASS TOINSTANCE
+ TRANSLATABLE QUALIFIER SCOPE SCHEMA PROPERTY REFERENCE
+ METHOD PARAMETER FLAVOR INSTANCE
+ AS REF ANY OF
+ DT_VOID
+ DT_UINT8 DT_SINT8 DT_UINT16 DT_SINT16 DT_UINT32 DT_SINT32
+ DT_UINT64 DT_SINT64 DT_REAL32 DT_REAL64 DT_CHAR16 DT_STR
+ DT_BOOLEAN DT_DATETIME
+ positiveDecimalValue
+ stringValue
+ realValue
+ charValue
+ booleanValue
+ nullValue
+ binaryValue
+ octalValue
+ decimalValue
+ hexValue
+
+rule
+
+ /* Returns a Hash of filename and MofResult */
+ mofSpecification
+ : /* empty */
+ { result = Hash.new }
+ | mofProduction
+ { result = { @name => @result } }
+ | mofSpecification mofProduction
+ { result = val[0]
+ result[@name] = @result
+ }
+ ;
+
+ mofProduction
+ : compilerDirective
+ | classDeclaration
+ { #puts "Class '#{val[0].name}'"
+ @result.classes << val[0]
+ }
+ | qualifierDeclaration
+ { @result.qualifiers << val[0]
+ @qualifiers[val[0].name.downcase] = val[0]
+ }
+ | instanceDeclaration
+ { @result.instances << val[0] }
+ ;
+
+/***
+ * compilerDirective
+ *
+ */
+
+ compilerDirective
+ : "#" PRAGMA INCLUDE pragmaParameters_opt
+ { raise MOF::Helper::Error.new(@name,@lineno,@line,"Missing filename after '#pragma include'") unless val[3]
+ open val[3], :pragma
+ }
+ | "#" PRAGMA pragmaName pragmaParameters_opt
+ | "#" INCLUDE pragmaParameters_opt
+ { raise StyleError.new(@name,@lineno,@line,"Use '#pragma include' instead of '#include'") unless @style == :wmi
+ raise MOF::Helper::Error.new(@name,@lineno,@line,"Missing filename after '#include'") unless val[2]
+ open val[2], :pragma
+ }
+ ;
+
+ pragmaName
+ : IDENTIFIER
+ ;
+
+ pragmaParameters_opt
+ : /* empty */
+ { raise StyleError.new(@name,@lineno,@line,"#pragma parameter missing") unless @style == :wmi }
+ | "(" pragmaParameterValues ")"
+ { result = val[1] }
+ ;
+
+ pragmaParameterValues
+ : pragmaParameterValue
+ | pragmaParameterValues "," pragmaParameterValue
+ ;
+
+ pragmaParameterValue
+ : string
+ | integerValue
+ { raise StyleError.new(@name,@lineno,@line,"#pragma parameter missing") unless @style == :wmi }
+ | IDENTIFIER
+ ;
+
+/***
+ * classDeclaration
+ *
+ */
+
+ classDeclaration
+ : qualifierList_opt CLASS className alias_opt superClass_opt "{" classFeatures "}" ";"
+ { qualifiers = val[0]
+ features = val[6]
+ # FIXME: features must not include references
+ result = CIM::Class.new(val[2],qualifiers,val[3],val[4],features)
+ }
+ ;
+
+ classFeatures
+ : /* empty */
+ { result = [] }
+ | classFeatures classFeature
+ { result = val[0] << val[1] }
+ ;
+
+ classFeature
+ : propertyDeclaration
+ | methodDeclaration
+ | referenceDeclaration /* must have association qualifier */
+ ;
+
+
+ qualifierList_opt
+ : /* empty */
+ | qualifierList
+ { result = CIM::QualifierSet.new val[0] }
+ ;
+
+ qualifierList
+ : "[" qualifier qualifiers "]"
+ { result = val[2]
+ result.unshift val[1] if val[1] }
+ ;
+
+ qualifiers
+ : /* empty */
+ { result = [] }
+ | qualifiers "," qualifier
+ { result = val[0]
+ result << val[2] if val[2]
+ }
+ ;
+
+ qualifier
+ : qualifierName qualifierParameter_opt flavor_opt
+ { # Get qualifier decl
+ qualifier = case val[0]
+ when CIM::Qualifier then val[0].definition
+ when CIM::QualifierDeclaration then val[0]
+ when String then @qualifiers[val[0].downcase]
+ else
+ nil
+ end
+ raise MOF::Helper::Error.new(@name,@lineno,@line,"'#{val[0]}' is not a valid qualifier") unless qualifier
+ value = val[1]
+ raise MOF::Helper::Error.new(@name,@lineno,@line,"#{value.inspect} does not match qualifier type '#{qualifier.type}'") unless qualifier.type.matches?(value)||@style == :wmi
+ # Don't propagate a boolean 'false'
+ if qualifier.type == :boolean && value == false
+ result = nil
+ else
+ result = CIM::Qualifier.new(qualifier,value,val[2])
+ end
+ }
+ ;
+
+ flavor_opt
+ : /* empty */
+ | ":" flavor
+ { result = CIM::QualifierFlavors.new val[1] }
+ ;
+
+ qualifierParameter_opt
+ : /* empty */
+ | qualifierParameter
+ ;
+
+ qualifierParameter
+ : "(" constantValue ")"
+ { result = val[1] }
+ | arrayInitializer
+ ;
+
+ /* CIM::Flavors */
+ flavor
+ : AMENDED | ENABLEOVERRIDE | DISABLEOVERRIDE | RESTRICTED | TOSUBCLASS | TRANSLATABLE | TOINSTANCE
+ { case val[0].to_sym
+ when :amended, :toinstance
+ raise StyleError.new(@name,@lineno,@line,"'#{val[0]}' is not a valid flavor") unless @style == :wmi
+ end
+ }
+ ;
+
+ alias_opt
+ : /* empty */
+ | alias
+ ;
+
+ superClass_opt
+ : /* empty */
+ | superClass
+ ;
+
+ className
+ : IDENTIFIER /* must be <schema>_<classname> in CIM v2.x */
+ { raise ParseError.new("Class name must be prefixed by '<schema>_'") unless val[0].include?("_") || @style == :wmi }
+ ;
+
+ alias
+ : AS aliasIdentifier
+ { result = val[1] }
+ ;
+
+ aliasIdentifier
+ : "$" IDENTIFIER /* NO whitespace ! */
+ { result = val[1] }
+ ;
+
+ superClass
+ : ":" className
+ { result = val[1] }
+ ;
+
+
+ propertyDeclaration
+ : qualifierList_opt dataType propertyName array_opt defaultValue_opt ";"
+ { if val[3]
+ type = CIM::Array.new val[3],val[1]
+ else
+ type = val[1]
+ end
+ result = CIM::Property.new(type,val[2],val[0],val[4])
+ }
+ ;
+
+ referenceDeclaration
+ : qualifierList_opt objectRef referenceName array_opt defaultValue_opt ";"
+ { if val[4]
+ raise StyleError.new(@name,@lineno,@line,"Array not allowed in reference declaration") unless @style == :wmi
+ end
+ result = CIM::Reference.new(val[1],val[2],val[0],val[4]) }
+ ;
+
+ methodDeclaration
+ : qualifierList_opt dataType methodName "(" parameterList_opt ")" ";"
+ { result = CIM::Method.new(val[1],val[2],val[0],val[4]) }
+ ;
+
+ propertyName
+ : IDENTIFIER
+ | PROPERTY
+ { # tmplprov.mof has 'string Property;'
+ raise StyleError.new(@name,@lineno,@line,"Invalid keyword '#{val[0]}' used for property name") unless @style == :wmi
+ }
+ ;
+
+ referenceName
+ : IDENTIFIER
+ | INDICATION
+ { result = "Indication" }
+ ;
+
+ methodName
+ : IDENTIFIER
+ ;
+
+ dataType
+ : DT_UINT8
+ | DT_SINT8
+ | DT_UINT16
+ | DT_SINT16
+ | DT_UINT32
+ | DT_SINT32
+ | DT_UINT64
+ | DT_SINT64
+ | DT_REAL32
+ | DT_REAL64
+ | DT_CHAR16
+ | DT_STR
+ | DT_BOOLEAN
+ | DT_DATETIME
+ | DT_VOID
+ { raise StyleError.new(@name,@lineno,@line,"'void' is not a valid datatype") unless @style == :wmi }
+ ;
+
+ objectRef
+ : className
+ { # WMI uses class names as data types (without REF ?!)
+ raise StyleError.new(@name,@lineno,@line,"Expected 'ref' keyword after classname '#{val[0]}'") unless @style == :wmi
+ result = CIM::ReferenceType.new val[0]
+ }
+
+ | className REF
+ { result = CIM::ReferenceType.new val[0] }
+ ;
+
+ parameterList_opt
+ : /* empty */
+ | parameterList
+ ;
+
+ parameterList
+ : parameter parameters
+ { result = val[1].unshift val[0] }
+ ;
+
+ parameters
+ : /* empty */
+ { result = [] }
+ | parameters "," parameter
+ { result = val[0] << val[2] }
+ ;
+
+ parameter
+ : qualifierList_opt typespec parameterName array_opt parameterValue_opt
+ { if val[3]
+ type = CIM::Array.new val[3], val[1]
+ else
+ type = val[1]
+ end
+ result = CIM::Property.new(type,val[2],val[0])
+ }
+ ;
+
+ typespec
+ : dataType
+ | objectRef
+ ;
+
+ parameterName
+ : IDENTIFIER
+ ;
+
+ array_opt
+ : /* empty */
+ | array
+ ;
+
+ parameterValue_opt
+ : /* empty */
+ | defaultValue
+ { raise "Default parameter value not allowed in syntax style '{@style}'" unless @style == :wmi }
+ ;
+
+ array
+ : "[" positiveDecimalValue_opt "]"
+ { result = val[1] }
+ ;
+
+ positiveDecimalValue_opt
+ : /* empty */
+ { result = -1 }
+ | positiveDecimalValue
+ ;
+
+ defaultValue_opt
+ : /* empty */
+ | defaultValue
+ ;
+
+ defaultValue
+ : "=" initializer
+ { result = val[1] }
+ ;
+
+ initializer
+ : constantValue
+ | arrayInitializer
+ | referenceInitializer
+ ;
+
+ arrayInitializer
+ : "{" constantValues "}"
+ { result = val[1] }
+ ;
+
+ constantValues
+ : /* empty */
+ | constantValue
+ { result = [ val[0] ] }
+ | constantValues "," constantValue
+ { result = val[0] << val[2] }
+ ;
+
+ constantValue
+ : integerValue
+ | realValue
+ | charValue
+ | string
+ | booleanValue
+ | nullValue
+ | instance
+ { raise "Instance as property value not allowed in syntax style '{@style}'" unless @style == :wmi }
+ ;
+
+ integerValue
+ : binaryValue
+ | octalValue
+ | decimalValue
+ | positiveDecimalValue
+ | hexValue
+ ;
+
+ string
+ : stringValue
+ | string stringValue
+ { result = val[0] + val[1] }
+ ;
+
+ referenceInitializer
+ : objectHandle
+ | aliasIdentifier
+ ;
+
+ objectHandle
+ : namespace_opt modelPath
+ ;
+
+ namespace_opt
+ : /* empty */
+ | namespaceHandle ":"
+ ;
+
+ namespaceHandle
+ : IDENTIFIER
+ ;
+
+ /*
+ * Note
+ : structure depends on type of namespace
+ */
+
+ modelPath
+ : className "." keyValuePairList
+ ;
+
+ keyValuePairList
+ : keyValuePair keyValuePairs
+ ;
+
+ keyValuePairs
+ : /* empty */
+ | keyValuePairs "," keyValuePair
+ ;
+
+ keyValuePair
+ : keyname "=" initializer
+ ;
+
+ keyname
+ : propertyName | referenceName
+ ;
+
+/***
+ * qualifierDeclaration
+ *
+ */
+
+ qualifierDeclaration
+ /* 0 1 2 3 4 */
+ : QUALIFIER qualifierName qualifierType scope defaultFlavor_opt ";"
+ { result = CIM::QualifierDeclaration.new( val[1], val[2][0], val[2][1], val[3], val[4]) }
+ ;
+
+ defaultFlavor_opt
+ : /* empty */
+ | defaultFlavor
+ ;
+
+ qualifierName
+ : IDENTIFIER
+ | ASSOCIATION /* meta qualifier */
+ | INDICATION /* meta qualifier */
+ | REFERENCE /* Added in DSP0004 2.7.0 */
+ | SCHEMA
+ ;
+
+ /* [type, value] */
+ qualifierType
+ : ":" dataType array_opt defaultValue_opt
+ { type = val[2].nil? ? val[1] : CIM::Array.new(val[2],val[1])
+ result = [ type, val[3] ]
+ }
+ ;
+
+ scope
+ : "," SCOPE "(" metaElements ")"
+ { result = CIM::QualifierScopes.new(val[3]) }
+ ;
+
+ metaElements
+ : metaElement
+ { result = [ val[0] ] }
+ | metaElements "," metaElement
+ { result = val[0] << val[2] }
+ ;
+
+ metaElement
+ : SCHEMA
+ | CLASS
+ | ASSOCIATION
+ | INDICATION
+ | QUALIFIER
+ | PROPERTY
+ | REFERENCE
+ | METHOD
+ | PARAMETER
+ | ANY
+ ;
+
+ defaultFlavor
+ : "," FLAVOR "(" flavors ")"
+ { result = CIM::QualifierFlavors.new val[3] }
+ ;
+
+ flavors
+ : flavor
+ { result = [ val[0] ] }
+ | flavors "," flavor
+ { result = val[0] << val[2] }
+ ;
+
+/***
+ * instanceDeclaration
+ *
+ */
+
+ instanceDeclaration
+ : instance ";"
+ ;
+
+ instance
+ : qualifierList_opt INSTANCE OF className alias_opt "{" valueInitializers "}"
+ ;
+
+ valueInitializers
+ : valueInitializer
+ | valueInitializers valueInitializer
+ ;
+
+ valueInitializer
+ : qualifierList_opt keyname "=" initializer ";"
+ | qualifierList_opt keyname ";"
+ { raise "Instance property '#{val[1]} must have a value" unless @style == :wmi }
+ ;
+
+end # class Parser
+
+---- header ----
+
+# parser.rb - generated by racc
+
+require 'strscan'
+require 'rubygems'
+require 'cim'
+require File.join(File.dirname(__FILE__), 'result')
+require File.join(File.dirname(__FILE__), 'scanner')
+require File.join(File.dirname(__FILE__), 'helper')
+
+---- inner ----
+
+#
+# Initialize MOF::Parser
+# MOF::Parser.new options = {}
+#
+# options -> Hash of options
+# :debug -> boolean
+# :includes -> array of include dirs
+# :style -> :cim or :wmi
+#
+def initialize options = {}
+ @yydebug = options[:debug]
+ @includes = options[:includes] || []
+ @quiet = options[:quiet]
+ @style = options[:style] || :cim # default to style CIM v2.2 syntax
+
+ @lineno = 1
+ @file = nil
+ @iconv = nil
+ @eol = "\n"
+ @fname = nil
+ @fstack = []
+ @in_comment = false
+ @seen_files = []
+ @qualifiers = {}
+end
+
+#
+# Make options hash from argv
+#
+# returns [ files, options ]
+#
+
+ def self.argv_handler name, argv
+ files = []
+ options = { :namespace => "" }
+ while argv.size > 0
+ case opt = argv.shift
+ when "-h"
+ $stderr.puts "Ruby MOF compiler"
+ $stderr.puts "#{name} [-h] [-d] [-I <dir>] [<moffiles>]"
+ $stderr.puts "Compiles <moffile>"
+ $stderr.puts "\t-d debug"
+ $stderr.puts "\t-h this help"
+ $stderr.puts "\t-I <dir> include dir"
+ $stderr.puts "\t-f force"
+ $stderr.puts "\t-n <namespace>"
+ $stderr.puts "\t-o <output>"
+ $stderr.puts "\t-s <style> syntax style (wmi,cim)"
+ $stderr.puts "\t-q quiet"
+ $stderr.puts "\t<moffiles> file(s) to read (else use $stdin)"
+ exit 0
+ when "-f" then options[:force] = true
+ when "-s" then options[:style] = argv.shift.to_sym
+ when "-d" then options[:debug] = true
+ when "-q" then options[:quiet] = true
+ when "-I"
+ options[:includes] ||= []
+ dirname = argv.shift
+ unless File.directory?(dirname)
+ files << dirname
+ dirname = File.dirname(dirname)
+ end
+ options[:includes] << Pathname.new(dirname)
+ when "-n" then options[:namespace] = argv.shift
+ when "-o" then options[:output] = argv.shift
+ when /^-.+/
+ $stderr.puts "Undefined option #{opt}"
+ else
+ files << opt
+ end
+ end
+ [ files, options ]
+ end
+
+include Helper
+include Scanner
+
+---- footer ----
generated by cgit v1.2.3 (git 2.39.1) at 2024-05-27 02:27:26 +0000