Ignore:
Timestamp:
Sep 20, 2009, 1:20:48 PM (15 years ago)
Author:
Tatsukawa, Akimichi
Message:

Scanners for ADL parser do not need yaparc library any more

File:
1 edited

Legend:

Unmodified
Added
Removed

  • ruby/trunk/lib/adl_parser/lib/parser.y

    r265 r283  
    5555      archetype.original_language = language
    5656    end
    57     @@logger.debug("#{__FILE__}:#{__LINE__}: archetype = #{archetype} at #{@filename}:#{@lineno}")
     57    @@logger.debug("#{__FILE__}:#{__LINE__}: archetype = #{archetype.to_yaml} at #{@filename}:#{@lineno}")
    5858    result = archetype
    5959  }
    … …  
    530530multiple_attr_object_block_head: SYM_START_DBLOCK
    531531  {
    532     @@logger.debug("SYM_START_DBLOCK: #{val[0]} at #{@filename}:#{@lineno}")
    533532    result = val[0]
    534533  }
    … …  
    546545  {
    547546    @@logger.debug("#{__FILE__}:#{__LINE__}: keyed_object = #{val[0]} at #{@filename}:#{@lineno}")
    548     result = {:object_key => val[0], :object_block => val[1]}
     547    result = {:object_key => val[0], :object_block => val[2]}
    549548  }
    550549
    … …  
    806805
    807806date_value: V_ISO8601_EXTENDED_DATE
     807  {
     808    result = val[0]
     809  }
    808810
    809811date_list_value: date_value Comma_code date_value
    … …  
    11941196$:.unshift File.join(File.dirname(__FILE__))
    11951197require 'logger'
     1198require 'yaml'
    11961199require 'rubygems'
    11971200require 'adl_parser.rb'
    11981201require 'am.rb'
    11991202require 'rm.rb'
    1200 $DEBUG = true
     1203$DEBUG = false
    12011204
    12021205
    … …  
    12181221end
    12191222
    1220 @@dadl_scanner = OpenEHR::ADL::Scanner::DADL::RootScanner.new
    1221 @@cadl_scanner = OpenEHR::ADL::Scanner::CADL::RootScanner.new
    12221223
    12231224###----------/* keywords */ ---------------------------------------------
    … …  
    12821283def scan
    12831284  @@logger.debug("#{__FILE__}:#{__LINE__}: Entering scan at #{@filename}:#{@lineno}:")
    1284   adl_scanner = OpenEHR::ADL::Scanner::ADLScanner.new(@adl_type, @filename)
    1285   cadl_scanner = OpenEHR::ADL::Scanner::CADLScanner.new(@adl_type, @filename)
    1286   dadl_scanner = OpenEHR::ADL::Scanner::DADLScanner.new(@adl_type, @filename)
    1287   regex_scanner = OpenEHR::ADL::Scanner::RegexScanner.new(@adl_type, @filename)
    1288   term_constraint_scanner = OpenEHR::ADL::Scanner::TermConstraintScanner.new(@adl_type, @filename)
     1285  scanner = OpenEHR::ADL::Scanner::ADLScanner.new(@adl_type, @filename)
    12891286
    12901287  until @data.nil?  do
    1291     case @adl_type.last
    1292     when :adl
    1293       @data = adl_scanner.scan(@data) do |sym, val|
     1288    @data = scanner.scan(@data) do |sym, val|
    12941289        yield sym, val
    1295       end
    1296     when :dadl
    1297       @data = dadl_scanner.scan(@data) do |sym, val|
    1298         yield sym, val
    1299       end
    1300     when :cadl
    1301       @data = cadl_scanner.scan(@data) do |sym, val|
    1302         yield sym, val
    1303       end
    1304     when :regexp
    1305       @data = regex_scanner.scan(@data) do |sym, val|
    1306         yield sym, val
    1307       end
    1308     when :term_constraint
    1309       @@logger.debug("#{__FILE__}:#{__LINE__}: scan: Entering scan_term_constraint at #{@filename}:#{@lineno}: data = #{@data.inspect}")
    1310       @data = term_constraint_scanner.scan(@data) do |sym, val|
    1311         yield sym, val
    1312       end
    1313     else
    1314       raise
    13151290    end
    13161291    @data = $' # variable $' receives the string after the match
    … …  
    13191294  yield false, '$'
    13201295end # of scan
    1321 
    1322 ### def scan
    1323 ###   @@logger.debug("#{__FILE__}:#{__LINE__}: Entering scan at #{@filename}:#{@lineno}:")
    1324  
    1325 ###   until @data.nil?  do
    1326 ###     case @adl_type.last
    1327 ###     when :adl
    1328 ###       @data = scan_adl(@data) do |sym, val|
    1329 ###         yield sym, val
    1330 ###       end
    1331 ###     when :dadl
    1332 ###       @data = scan_dadl(@data) do |sym, val|
    1333 ###         yield sym, val
    1334 ###       end
    1335 ###     when :cadl
    1336 ###       @data = scan_cadl(@data) do |sym, val|
    1337 ###         yield sym, val
    1338 ###       end
    1339 ###     when :regexp
    1340 ###       @data = scan_regexp(@data) do |sym, val|
    1341 ###         yield sym, val
    1342 ###       end
    1343 ###     when :term_constraint
    1344 ###       @@logger.debug("#{__FILE__}:#{__LINE__}: scan: Entering scan_term_constraint at #{@filename}:#{@lineno}: data = #{data.inspect}")
    1345 ###       @data = scan_term_constraint(@data) do |sym, val|
    1346 ###         yield sym, val
    1347 ###       end
    1348 ###     else
    1349 ###       raise
    1350 ###     end
    1351 ###     @data = $' # variable $' receives the string after the match
    1352 ###   end
    1353 ###   yield :EOF, nil
    1354 ###   yield false, '$'
    1355 ### end # of scan
    1356 
    1357 def scan_adl(data)
    1358   @@logger.debug("#{__FILE__}:#{__LINE__}: Entering scan_adl at #{@filename}:#{@lineno}: data = #{data.inspect}")
    1359   until data.nil?  do
    1360     case @adl_type.last
    1361     when :adl
    1362       case data
    1363       when /\A\n/ # carriage return
    1364         @lineno += 1
    1365         ;
    1366       when /\A[ \t\r\f]+/ #just drop it
    1367         ;
    1368       when /\A--.*\n/ # single line comment
    1369         @lineno += 1
    1370         @@logger.debug("#{__FILE__}:#{__LINE__}: scan_adl: COMMENT = #{$&} at #{@filename}:#{@lineno}")
    1371         ;
    1372       when /\Adescription/   # description
    1373         yield :SYM_DESCRIPTION, :SYM_DESCRIPTION
    1374       when /\Adefinition/   # definition
    1375         yield :SYM_DEFINITION, :SYM_DEFINITION
    1376         ###----------/* symbols */ -------------------------------------------------
    1377       when /\A[A-Z][a-zA-Z0-9_]*/
    1378         yield :V_TYPE_IDENTIFIER, $&
    1379 #      when /\A[a-zA-Z][a-zA-Z0-9_-]+\.[a-zA-Z][a-zA-Z0-9_-]+\.[a-zA-Z0-9]+/   #V_ARCHETYPE_ID
    1380       when /\A(\w+)-(\w+)-(\w+)\.(\w+)(-\w+)?\.(v\w+)/   #V_ARCHETYPE_ID
    1381         object_id, rm_originator, rm_name, rm_entity, concept_name, specialisation, version_id = $&, $1, $2, $3, $4, $5, $6
    1382         archetype_id = OpenEHR::RM::Support::Identification::Archetype_ID.new(object_id, concept_name, rm_name, rm_entity, rm_originator, specialisation, version_id)
    1383 #        yield :V_ARCHETYPE_ID, $&
    1384         yield :V_ARCHETYPE_ID, archetype_id
    1385       when /\A[a-z][a-zA-Z0-9_]*/
    1386 #        word = $&.downcase
    1387         word = $&
    1388         if @@adl_reserved[word]
    1389           @@logger.debug("#{__FILE__}:#{__LINE__}: scan_adl: @@adl_reserved = #{@@adl_reserved[word]} at #{@filename}:#{@lineno}")
    1390           yield @@adl_reserved[word], @@adl_reserved[word]
    1391         elsif #/\A[A-Z][a-zA-Z0-9_]*/
    1392           @@logger.debug("#{__FILE__}:#{__LINE__}: scan_adl: V_ATTRIBUTE_IDENTIFIER = #{$&} at #{@filename}:#{@lineno}")
    1393           yield :V_ATTRIBUTE_IDENTIFIER, $&
    1394         end
    1395       when /\A\=/   # =
    1396         yield :SYM_EQ, :SYM_EQ
    1397       when /\A\>=/   # >=
    1398         yield :SYM_GE, :SYM_GE
    1399       when /\A\<=/   # <=
    1400         yield :SYM_LE, :SYM_LE
    1401       when /\A\</   # <
    1402         if @in_interval
    1403 #          @start_block_received = false
    1404           yield :SYM_LT, :SYM_LT
    1405         else
    1406 #          @start_block_received = true
    1407           @adl_type.push(:dadl)
    1408           yield :SYM_START_DBLOCK,  $&
    1409         end
    1410       when /\A\>/   # >
    1411         if @in_interval
    1412           yield :SYM_GT, :SYM_GT
    1413         else
    1414           adl_type = @adl_type.pop
    1415           assert_at(__FILE__,__LINE__){adl_type == :dadl}
    1416           yield :SYM_END_DBLOCK, :SYM_END_DBLOCK
    1417         end
    1418       when /\A\{/   # {
    1419         @adl_type.push(:cadl)
    1420         @@logger.debug("#{__FILE__}:#{__LINE__}: scan_cadl: entering cADL at #{@filename}:#{@lineno}")
    1421         yield :SYM_START_CBLOCK, :SYM_START_CBLOCK
    1422       when /\A\}/   # }
    1423         adl_type = @adl_type.pop
    1424 #        puts "Escaping #{adl_type}"
    1425         assert_at(__FILE__,__LINE__){adl_type == :cadl}
    1426         @@logger.debug("#{__FILE__}:#{__LINE__}: scan_cadl: exiting cADL at #{@filename}:#{@lineno}")
    1427         yield :SYM_END_CBLOCK, $&
    1428       when /\A\-/   # -
    1429         yield :Minus_code, :Minus_code
    1430       when /\A\+/   # +
    1431         yield :Plus_code, :Plus_code
    1432       when /\A\*/   # *
    1433         yield :Star_code, :Star_code
    1434       when /\A\//   # /
    1435         yield :Slash_code, :Slash_code
    1436       when /\A\^/   # ^
    1437         yield :Caret_code, :Caret_code
    1438       when /\A\=/   # =
    1439         yield :Equal_code, :Equal_code
    1440       when /\A\.\.\./   # ...
    1441         yield :SYM_LIST_CONTINUE, :SYM_LIST_CONTINUE
    1442       when /\A\.\./   # ..
    1443         yield :SYM_ELLIPSIS, :SYM_ELLIPSIS
    1444       when /\A\./   # .
    1445         yield :Dot_code, :Dot_code
    1446       when /\A\;/   # ;
    1447         yield :Semicolon_code, :Semicolon_code
    1448       when /\A\,/   # ,
    1449         yield :Comma_code, :Comma_code
    1450       when /\A\:/   # :
    1451         yield :Colon_code, :Colon_code
    1452       when /\A\!/   # !
    1453         yield :Exclamation_code, :Exclamation_code
    1454       when /\A\(/   # (
    1455         yield :Left_parenthesis_code, :Left_parenthesis_code
    1456       when /\A\)/   # )
    1457         yield :Right_parenthesis_code, :Right_parenthesis_code
    1458       when /\A\$/   # $
    1459         yield :Dollar_code, :Dollar_code
    1460       when /\A\?\?/   # ??
    1461         yield :SYM_DT_UNKNOWN, :SYM_DT_UNKNOWN
    1462       when /\A\?/   # ?
    1463         yield :Question_mark_code, :Question_mark_code
    1464       when /\A[0-9]+\.[0-9]+(\.[0-9]+)*/   # ?
    1465         yield :V_VERSION_STRING, $&
    1466       when /\A\|/   # |
    1467         if @in_interval
    1468           @in_interval = false
    1469         else
    1470           @in_interval = true
    1471         end
    1472         yield :SYM_INTERVAL_DELIM, :SYM_INTERVAL_DELIM
    1473       when /\A\[[a-zA-Z0-9()\._-]+::[a-zA-Z0-9\._-]+\]/
    1474 #      when /\A\[[a-zA-Z0-9()\._-]+\:\:[a-zA-Z0-9\._-]+\]/   #V_QUALIFIED_TERM_CODE_REF form [ICD10AM(1998)::F23]
    1475         yield :V_QUALIFIED_TERM_CODE_REF, $&
    1476       when /\A\[[a-zA-Z0-9][a-zA-Z0-9._\-]*\]/   #V_LOCAL_TERM_CODE_REF
    1477         yield :V_LOCAL_TERM_CODE_REF, $&
    1478       when /\A\[/   # [
    1479         yield :Left_bracket_code, :Left_bracket_code
    1480       when /\A\]/   # ]
    1481         yield :Right_bracket_code, :Right_bracket_code
    1482 
    1483       when /\A"([^"]*)"/m #V_STRING
    1484         yield :V_STRING, $1
    1485       when /\A\[[a-zA-Z0-9._\- ]+::[a-zA-Z0-9._\- ]+\]/   #ERR_V_QUALIFIED_TERM_CODE_REF
    1486         yield :ERR_V_QUALIFIED_TERM_CODE_REF, $&
    1487       when /\Aa[ct][0-9.]+/   #V_LOCAL_CODE
    1488         yield :V_LOCAL_CODE, $&
    1489       when /\A[0-9]{4}-[0-1][0-9]-[0-3][0-9]T[0-2][0-9]:[0-6][0-9]:[0-6][0-9](,[0-9]+)?(Z|[+-][0-9]{4})?|[0-9]{4}-[0-1][0-9]-[0-3][0-9]T[0-2][0-9]:[0-6][0-9](Z|[+-][0-9]{4})?|[0-9]{4}-[0-1][0-9]-[0-3][0-9]T[0-2][0-9](Z|[+-][0-9]{4})?/   #V_ISO8601_EXTENDED_DATE_TIME YYYY-MM-DDThh:mm:ss[,sss][Z|+/- -n-n-n-n-]-
    1490         yield :V_ISO8601_EXTENDED_DATE_TIME, $&
    1491       when /\A[0-2][0-9]:[0-6][0-9]:[0-6][0-9](,[0-9]+)?(Z|[+-][0-9]{4})?|[0-2][0-9]:[0-6][0-9](Z|[+-][0-9]{4})? /   #V_ISO8601_EXTENDED_TIME hh:mm:ss[,sss][Z|+/-nnnn]
    1492         yield :V_ISO8601_EXTENDED_TIME, $&
    1493       when /\A[0-9]{4}-[0-1][0-9]-[0-3][0-9]|[0-9]{4}-[0-1][0-9]/   #V_ISO8601_EXTENDED_DATE YYYY-MM-DD
    1494         yield :V_ISO8601_EXTENDED_DATE, $&
    1495       when /\A[A-Z][a-zA-Z0-9_]*<[a-zA-Z0-9,_<>]+>/   #V_GENERIC_TYPE_IDENTIFIER
    1496         yield :V_GENERIC_TYPE_IDENTIFIER, $&
    1497       when /\A[0-9]+|[0-9]+[eE][+-]?[0-9]+/   #V_INTEGER
    1498         yield :V_INTEGER, $&
    1499       when /\A[0-9]+\.[0-9]+|[0-9]+\.[0-9]+[eE][+-]?[0-9]+ /   #V_REAL
    1500         yield :V_REAL, $&
    1501         #    when /\A"((?:[^"\\]+|\\.)*)"/ #V_STRING
    1502       when /\A[a-z]+:\/\/[^<>|\\{}^~"\[\] ]*/ #V_URI
    1503         yield :V_URI, $&
    1504       when /\AP([0-9]+[yY])?([0-9]+[mM])?([0-9]+[wW])?([0-9]+[dD])?T([0-9]+[hH])?([0-9]+[mM])?([0-9]+[sS])?|P([0-9]+[yY])?([0-9]+[mM])?([0-9]+[wW])?([0-9]+[dD])?/   #V_ISO8601_DURATION PnYnMnWnDTnnHnnMnnS
    1505         yield :V_ISO8601_DURATION, $&
    1506       when /\A\S/ #UTF8CHAR
    1507         yield :UTF8CHAR, $&
    1508       end
    1509       data = $' # variable $' receives the string after the match
    1510     when :dadl
    1511       data = scan_dadl(data) do |sym, val|
    1512         yield sym, val
    1513       end
    1514     when :cadl
    1515       data = scan_cadl(data) do |sym, val|
    1516         yield sym, val
    1517       end
    1518     when :regexp
    1519       data = scan_regexp(data) do |sym, val|
    1520         yield sym, val
    1521       end
    1522     when :term_constraint
    1523       @@logger.debug("#{__FILE__}:#{__LINE__}: scan_adl: Entering scan_term_constraint at #{@filename}:#{@lineno}: data = #{data.inspect}")
    1524 
    1525       data = scan_term_constraint(data) do |sym, val|
    1526         yield sym, val
    1527       end
    1528     else
    1529       raise
    1530     end
    1531   end
    1532 end # scan_adl
    1533 
    1534 
    1535 def scan_cadl(data)
    1536   @@logger.debug("#{__FILE__}:#{__LINE__}: Entering scan_cadl at #{@filename}:#{@lineno}: data = #{data.inspect}")
    1537   until data.nil?  do
    1538     case @adl_type.last
    1539     when :cadl
    1540       case scanned = @@cadl_scanner.parse(data)
    1541       when Yaparc::Result::OK
    1542         if scanned.value[0] == :START_V_C_DOMAIN_TYPE_BLOCK
    1543           @in_c_domain_type = true
    1544           @adl_type.push(:dadl)
    1545           yield scanned.value
    1546         else
    1547           yield scanned.value
    1548         end
    1549         data = scanned.input
    1550       end
    1551 
    1552       case data
    1553       when /\A\n/ # carriage return
    1554         @lineno += 1
    1555         ;
    1556       when /\A[ \t\r\f]+/ #just drop it
    1557         ;
    1558       when /\A--.*\n/ # single line comment
    1559         @lineno += 1
    1560         @@logger.debug("#{__FILE__}:#{__LINE__}: scan_cadl: COMMENT = #{$&} at #{@filename}:#{@lineno}")
    1561         ;
    1562         ###----------/* symbols */ -------------------------------------------------
    1563       when /\A\=/   # =
    1564         yield :SYM_EQ, :SYM_EQ
    1565       when /\A\>=/   # >=
    1566         yield :SYM_GE, :SYM_GE
    1567       when /\A\<=/   # <=
    1568         yield :SYM_LE, :SYM_LE
    1569 ###       when /\A[A-Z][a-zA-Z0-9_]*[ \n]*\</   # V_C_DOMAIN_TYPE
    1570 ###         @in_c_domain_type = true
    1571 ###         @adl_type.push(:dadl)
    1572 ###         yield :START_V_C_DOMAIN_TYPE_BLOCK, $&
    1573       when /\A\</   # <
    1574         if @in_interval
    1575           yield :SYM_LT, :SYM_LT
    1576         else
    1577           @adl_type.push(:dadl)
    1578           yield :SYM_START_DBLOCK,  $&
    1579         end
    1580       when /\A\>/   # >
    1581         if @in_interval
    1582           yield :SYM_GT, :SYM_GT
    1583         else
    1584           adl_type = @adl_type.pop
    1585 #          puts "Escaping #{adl_type}"
    1586           assert_at(__FILE__,__LINE__){adl_type == :dadl}
    1587           yield :SYM_END_DBLOCK, :SYM_END_DBLOCK
    1588         end
    1589       when /\A\-/   # -
    1590         yield :Minus_code, :Minus_code
    1591       when /\A\+/   # +
    1592         yield :Plus_code, :Plus_code
    1593       when /\A\*/   # *
    1594         yield :Star_code, :Star_code
    1595       when /\A\//   # /
    1596         yield :Slash_code, :Slash_code
    1597       when /\A\^/   # ^
    1598         yield :Caret_code, :Caret_code
    1599       when /\A\.\.\./   # ...
    1600         yield :SYM_LIST_CONTINUE, :SYM_LIST_CONTINUE
    1601       when /\A\.\./   # ..
    1602         yield :SYM_ELLIPSIS, :SYM_ELLIPSIS
    1603       when /\A\./   # .
    1604         yield :Dot_code, :Dot_code
    1605       when /\A\;/   # ;
    1606         yield :Semicolon_code, :Semicolon_code
    1607       when /\A\,/   # ,
    1608         yield :Comma_code, :Comma_code
    1609       when /\A\:/   # :
    1610         yield :Colon_code, :Colon_code
    1611       when /\A\!/   # !
    1612         yield :Exclamation_code, :Exclamation_code
    1613       when /\A\(/   # (
    1614         yield :Left_parenthesis_code, :Left_parenthesis_code
    1615       when /\A\)/   # )
    1616         yield :Right_parenthesis_code, :Right_parenthesis_code
    1617       when /\A\{\// #V_REGEXP
    1618         if @adl_type.last != :regexp
    1619           @in_regexp = true
    1620           @adl_type.push(:regexp)
    1621           yield :START_REGEXP_BLOCK, :START_REGEXP_BLOCK
    1622         else
    1623           raise
    1624         end
    1625 #        yield :V_REGEXP, :V_REGEXP
    1626       when /\A\{/   # {
    1627         @adl_type.push(:cadl)
    1628         @@logger.debug("#{__FILE__}:#{__LINE__}: scan_cadl: entering cADL at #{@filename}:#{@lineno}")
    1629         yield :SYM_START_CBLOCK, :SYM_START_CBLOCK
    1630       when /\A\}/   # }
    1631         adl_type = @adl_type.pop
    1632 #        puts "Escaping #{adl_type}"
    1633         assert_at(__FILE__,__LINE__){adl_type == :cadl}
    1634         @@logger.debug("#{__FILE__}:#{__LINE__}: scan_cadl: exiting cADL at #{@filename}:#{@lineno}")
    1635         yield :SYM_END_CBLOCK, :SYM_END_CBLOCK
    1636       when /\A\$/   # $
    1637         yield :Dollar_code, :Dollar_code
    1638       when /\A\?\?/   # ??
    1639         yield :SYM_DT_UNKNOWN, :SYM_DT_UNKNOWN
    1640       when /\A\?/   # ?
    1641         yield :Question_mark_code, :Question_mark_code
    1642       when /\A\|/   # |
    1643         @@logger.debug("#{__FILE__}:#{__LINE__}: scan_cadl: @in_interval = #{@in_interval} at #{@filename}:#{@lineno}")
    1644         if @in_interval
    1645           @in_interval = false
    1646         else
    1647 #          @in_interval = false
    1648           @in_interval = true
    1649         end
    1650         @@logger.debug("#{__FILE__}:#{__LINE__}: scan_cadl: SYM_INTERVAL_DELIM at #{@filename}:#{@lineno}")
    1651         yield :SYM_INTERVAL_DELIM, :SYM_INTERVAL_DELIM
    1652 
    1653       when /\A\[[a-zA-Z0-9()\._-]+::[a-zA-Z0-9\._-]+\]/  #V_QUALIFIED_TERM_CODE_REF form [ICD10AM(1998)::F23]
    1654 #      when /\A\[[a-zA-Z0-9._\-]+::[a-zA-Z0-9._\-]+\]/   #V_QUALIFIED_TERM_CODE_REF form [ICD10AM(1998)::F23]
    1655         yield :V_QUALIFIED_TERM_CODE_REF, $&
    1656       when /\A\[[a-zA-Z0-9._\- ]+::[a-zA-Z0-9._\- ]+\]/   #ERR_V_QUALIFIED_TERM_CODE_REF
    1657         yield :ERR_V_QUALIFIED_TERM_CODE_REF, $&
    1658       when /\A\[([a-zA-Z0-9\(\)\._\-]+)::[ \t\n]*/
    1659         @adl_type.push(:term_constraint)
    1660         yield :START_TERM_CODE_CONSTRAINT, $1
    1661       when /\A\[[a-zA-Z0-9][a-zA-Z0-9._\-]*\]/   #V_LOCAL_TERM_CODE_REF
    1662         yield :V_LOCAL_TERM_CODE_REF, $&
    1663       when /\A\[/   # [
    1664         yield :Left_bracket_code, :Left_bracket_code
    1665       when /\A\]/   # ]
    1666         yield :Right_bracket_code, :Right_bracket_code
    1667       when /\A[A-Z][a-zA-Z0-9_]*<[a-zA-Z0-9,_<>]+>/   #V_GENERIC_TYPE_IDENTIFIER
    1668         yield :V_GENERIC_TYPE_IDENTIFIER, $&
    1669       when /\A[yY][yY][yY][yY]-[mM?X][mM?X]-[dD?X][dD?X][T\t][hH?X][hH?X]:[mM?X][mM?X]:[sS?X][sS?X]/
    1670         yield :V_ISO8601_DATE_TIME_CONSTRAINT_PATTERN, $&
    1671       when /\A[yY][yY][yY][yY]-[mM?X][mM?X]-[dD?X][dD?X]/
    1672         yield :V_ISO8601_DATE_CONSTRAINT_PATTERN, $&
    1673       when /\A[hH][hH]:[mM?X][mM?X]:[sS?X][sS?X]/
    1674         yield :V_ISO8601_TIME_CONSTRAINT_PATTERN, $&
    1675       when /\A[a-z][a-zA-Z0-9_]*/
    1676         word = $&.dup
    1677         if @@cadl_reserved[word.downcase]
    1678           yield @@cadl_reserved[word.downcase], @@cadl_reserved[word.downcase]
    1679         else
    1680           @@logger.debug("#{__FILE__}:#{__LINE__}: scan_cadl: V_ATTRIBUTE_IDENTIFIER = #{word} at #{@filename}:#{@lineno}")
    1681           yield :V_ATTRIBUTE_IDENTIFIER, word #V_ATTRIBUTE_IDENTIFIER /\A[a-z][a-zA-Z0-9_]*/
    1682         end
    1683       when /\A[A-Z][a-zA-Z0-9_]*/
    1684         word = $&.dup
    1685         if @@cadl_reserved[word.downcase]
    1686           yield @@cadl_reserved[word.downcase], @@cadl_reserved[word.downcase]
    1687         else
    1688           yield :V_TYPE_IDENTIFIER, $&
    1689         end
    1690       when /\Aa[ct][0-9.]+/   #V_LOCAL_CODE
    1691         yield :V_LOCAL_CODE, $&
    1692       when /\A[0-9]{4}-[0-1][0-9]-[0-3][0-9]T[0-2][0-9]:[0-6][0-9]:[0-6][0-9](,[0-9]+)?(Z|[+-][0-9]{4})?|[0-9]{4}-[0-1][0-9]-[0-3][0-9]T[0-2][0-9]:[0-6][0-9](Z|[+-][0-9]{4})?|[0-9]{4}-[0-1][0-9]-[0-3][0-9]T[0-2][0-9](Z|[+-][0-9]{4})?/   #V_ISO8601_EXTENDED_DATE_TIME YYYY-MM-DDThh:mm:ss[,sss][Z|+/- -n-n-n-n-]-
    1693         yield :V_ISO8601_EXTENDED_DATE_TIME, $&
    1694       when /\A[0-2][0-9]:[0-6][0-9]:[0-6][0-9](,[0-9]+)?(Z|[+-][0-9]{4})?|[0-2][0-9]:[0-6][0-9](Z|[+-][0-9]{4})? /   #V_ISO8601_EXTENDED_TIME hh:mm:ss[,sss][Z|+/-nnnn]
    1695         yield :V_ISO8601_EXTENDED_TIME, $&
    1696       when /\A[0-9]{4}-[0-1][0-9]-[0-3][0-9]|[0-9]{4}-[0-1][0-9]/   #V_ISO8601_EXTENDED_DATE YYYY-MM-DD
    1697         yield :V_ISO8601_EXTENDED_DATE, $&
    1698       when /\A[0-9]+|[0-9]+[eE][+-]?[0-9]+/   #V_INTEGER
    1699         yield :V_INTEGER, $&
    1700       when /\A[0-9]+\.[0-9]+|[0-9]+\.[0-9]+[eE][+-]?[0-9]+ /   #V_REAL
    1701         yield :V_REAL, $&
    1702            when /\A"((?:[^"\\]+|\\.)*)"/ #V_STRING
    1703       when /\A"([^"]*)"/m #V_STRING
    1704         yield :V_STRING, $1
    1705       when /\A[a-z]+:\/\/[^<>|\\{}^~"\[\] ]*/ #V_URI
    1706         yield :V_URI, $&
    1707 ###       when /\AP([0-9]+[yY])?([0-9]+[mM])?([0-9]+[wW])?([0-9]+[dD])?T([0-9]+[hH])?([0-9]+[mM])?([0-9]+[sS])?|P([0-9]+[yY])?([0-9]+[mM])?([0-9]+[wW])?([0-9]+[dD])?/   #V_ISO8601_DURATION PnYnMnWnDTnnHnnMnnS
    1708 ###         yield :V_ISO8601_DURATION, $&
    1709       when /\A\S/ #UTF8CHAR
    1710         yield :UTF8CHAR, $&
    1711       else
    1712         raise
    1713       end
    1714       data = $' # variable $' receives the string after the match
    1715     when :adl
    1716       data = scan_adl(data) do |sym, val|
    1717         yield sym, val
    1718       end
    1719     when :dadl
    1720       data = scan_dadl(data) do |sym, val|
    1721         yield sym, val
    1722       end
    1723     when :regexp
    1724       data = scan_regexp(data) do |sym, val|
    1725         yield sym, val
    1726       end
    1727     when :term_constraint
    1728       @@logger.debug("#{__FILE__}:#{__LINE__}: scan_cadl: Entering scan_term_constraint at #{@filename}:#{@lineno}: data = #{data.inspect}")
    1729      
    1730       data = scan_term_constraint(data) do |sym, val|
    1731         yield sym, val
    1732       end
    1733     else
    1734       raise
    1735     end
    1736   end # of until
    1737 end # of scan_cadl
    1738 
    1739 def scan_dadl(data)
    1740   @@logger.debug("#{__FILE__}:#{__LINE__}: Entering scan_dadl at #{@filename}:#{@lineno}: data = #{data.inspect}")
    1741   until data.nil?  do
    1742     case @adl_type.last
    1743     when :dadl
    1744       case scanned = @@dadl_scanner.parse(data)
    1745       when Yaparc::Result::OK
    1746         yield scanned.value
    1747         data = scanned.input
    1748       else
    1749       end
    1750 
    1751       case data
    1752       when /\A\n/ # carriage return
    1753         @lineno += 1
    1754         ;
    1755       when /\A[ \t\r\f]+/ #just drop it
    1756         ;
    1757       when /\A--.*\n/ # single line comment
    1758         @lineno += 1
    1759         @@logger.debug("#{__FILE__}:#{__LINE__}: scan_dadl: COMMENT = #{$&} at #{@filename}:#{@lineno}")
    1760         ;
    1761         ###----------/* symbols */ -------------------------------------------------
    1762       when /\A\=/   # =
    1763         yield :SYM_EQ, :SYM_EQ
    1764       when /\A\>\=/   # >=
    1765         yield :SYM_GE, :SYM_GE
    1766       when /\A\<\=/   # <=
    1767         yield :SYM_LE, :SYM_LE
    1768       when /\A\</   # <
    1769         if @in_interval
    1770           yield :SYM_LT, :SYM_LT
    1771         else
    1772           @adl_type.push(:dadl)
    1773           yield :SYM_START_DBLOCK, :SYM_START_DBLOCK
    1774         end
    1775       when /\A\>/   # >
    1776         if @in_interval
    1777 #          @in_interval = false
    1778           yield :SYM_GT, :SYM_GT
    1779         elsif @in_c_domain_type == true
    1780           assert_at(__FILE__,__LINE__){@adl_type.last == :dadl}
    1781           adl_type = @adl_type.pop
    1782           if @adl_type.last == :cadl
    1783             @in_c_domain_type = false
    1784             yield :END_V_C_DOMAIN_TYPE_BLOCK, $&
    1785           else
    1786             yield :SYM_END_DBLOCK, $&
    1787           end
    1788         elsif @in_c_domain_type == false
    1789           adl_type = @adl_type.pop
    1790           assert_at(__FILE__,__LINE__){adl_type == :dadl}
    1791           yield :SYM_END_DBLOCK, $&
    1792         else
    1793           raise
    1794         end
    1795       when /\A\-/   # -
    1796         yield :Minus_code, :Minus_code
    1797       when /\A\+/   # +
    1798         yield :Plus_code, :Plus_code
    1799       when /\A\*/   # *
    1800         yield :Star_code, :Star_code
    1801       when /\A\//   # /
    1802         yield :Slash_code, :Slash_code
    1803       when /\A\^/   # ^
    1804         yield :Caret_code, :Caret_code
    1805       when /\A\.\.\./   # ...
    1806         yield :SYM_LIST_CONTINUE, :SYM_LIST_CONTINUE
    1807       when /\A\.\./   # ..
    1808         yield :SYM_ELLIPSIS, :SYM_ELLIPSIS
    1809       when /\A\./   # .
    1810         yield :Dot_code, :Dot_code
    1811       when /\A\;/   # ;
    1812         yield :Semicolon_code, :Semicolon_code
    1813       when /\A\,/   # ,
    1814         yield :Comma_code, :Comma_code
    1815       when /\A\:/   # :
    1816         yield :Colon_code, :Colon_code
    1817       when /\A\!/   # !
    1818         yield :Exclamation_code, :Exclamation_code
    1819       when /\A\(/   # (
    1820         yield :Left_parenthesis_code, :Left_parenthesis_code
    1821       when /\A\)/   # )
    1822         yield :Right_parenthesis_code, :Right_parenthesis_code
    1823       when /\A\$/   # $
    1824         yield :Dollar_code, :Dollar_code
    1825       when /\A\?\?/   # ??
    1826         yield :SYM_DT_UNKNOWN, :SYM_DT_UNKNOWN
    1827       when /\A\?/   # ?
    1828         yield :Question_mark_code, :Question_mark_code
    1829       when /\A\|/   # |
    1830         @@logger.debug("#{__FILE__}:#{__LINE__}: scan_dadl: @in_interval = #{@in_interval} at #{@filename}:#{@lineno}")
    1831         if @in_interval
    1832           @in_interval = false
    1833         else
    1834 #          @in_interval = false
    1835           @in_interval = true
    1836         end
    1837         @@logger.debug("#{__FILE__}:#{__LINE__}: scan_dadl: SYM_INTERVAL_DELIM at #{@filename}:#{@lineno}")
    1838         yield :SYM_INTERVAL_DELIM, :SYM_INTERVAL_DELIM
    1839 ###       when /\A\[[a-zA-Z0-9()\._-]+::[a-zA-Z0-9\._-]+\]/   #V_QUALIFIED_TERM_CODE_REF form [ICD10AM(1998)::F23]
    1840 ###         yield :V_QUALIFIED_TERM_CODE_REF, $&
    1841 ###       when /\A\[[a-zA-Z0-9][a-zA-Z0-9._\-]*\]/   #V_LOCAL_TERM_CODE_REF
    1842 ###         yield :V_LOCAL_TERM_CODE_REF, $&
    1843 ###       when /\A\[[a-zA-Z0-9._\- ]+::[a-zA-Z0-9._\- ]+\]/   #ERR_V_QUALIFIED_TERM_CODE_REF
    1844 ###         yield :ERR_V_QUALIFIED_TERM_CODE_REF, $&
    1845       when /\A\[/   # [
    1846         yield :Left_bracket_code, :Left_bracket_code
    1847       when /\A\]/   # ]
    1848         yield :Right_bracket_code, :Right_bracket_code
    1849 ###       when /\A[A-Z][a-zA-Z0-9_-]*/
    1850 ###         yield :V_TYPE_IDENTIFIER, $&
    1851 ###       when /\A[A-Z][a-zA-Z0-9_]*<[a-zA-Z0-9,_<>]+>/   #V_GENERIC_TYPE_IDENTIFIER
    1852 ###         yield :V_GENERIC_TYPE_IDENTIFIER, $&
    1853 ###       when /\A[a-z][a-zA-Z0-9_]*/
    1854 ###         word = $&.downcase
    1855 ###         if @@dadl_reserved[word]
    1856 ###           yield @@dadl_reserved[word], @@dadl_reserved[word]
    1857 ###         else
    1858 ###           yield :V_ATTRIBUTE_IDENTIFIER, $&
    1859 ###         end
    1860 ###       when /\Aa[ct][0-9.]+/   #V_LOCAL_CODE
    1861 ###         yield :V_LOCAL_CODE, $&
    1862       when /\A[0-9]{4}-[0-1][0-9]-[0-3][0-9]T[0-2][0-9]:[0-6][0-9]:[0-6][0-9](,[0-9]+)?(Z|[+-][0-9]{4})?|[0-9]{4}-[0-1][0-9]-[0-3][0-9]T[0-2][0-9]:[0-6][0-9](Z|[+-][0-9]{4})?|[0-9]{4}-[0-1][0-9]-[0-3][0-9]T[0-2][0-9](Z|[+-][0-9]{4})?/   #V_ISO8601_EXTENDED_DATE_TIME YYYY-MM-DDThh:mm:ss[,sss][Z|+/- -n-n-n-n-]-
    1863         yield :V_ISO8601_EXTENDED_DATE_TIME, $&
    1864       when /\A[0-2][0-9]:[0-6][0-9]:[0-6][0-9](,[0-9]+)?(Z|[+-][0-9]{4})?|[0-2][0-9]:[0-6][0-9](Z|[+-][0-9]{4})? /   #V_ISO8601_EXTENDED_TIME hh:mm:ss[,sss][Z|+/-nnnn]
    1865         yield :V_ISO8601_EXTENDED_TIME, $&
    1866       when /\A[0-9]{4}-[0-1][0-9]-[0-3][0-9]|[0-9]{4}-[0-1][0-9]/   #V_ISO8601_EXTENDED_DATE YYYY-MM-DD
    1867         yield :V_ISO8601_EXTENDED_DATE, $&
    1868       when /\A[A-Z][a-zA-Z0-9_]*<[a-zA-Z0-9,_<>]+>/   #V_GENERIC_TYPE_IDENTIFIER
    1869         yield :V_GENERIC_TYPE_IDENTIFIER, $&
    1870       when /\A[0-9]+|[0-9]+[eE][+-]?[0-9]+/   #V_INTEGER
    1871         yield :V_INTEGER, $&
    1872 ###       when /\A[0-9]+\.[0-9]+|[0-9]+\.[0-9]+[eE][+-]?[0-9]+ /   #V_REAL
    1873 ###         yield :V_REAL, $&
    1874         #    when /\A"((?:[^"\\]+|\\.)*)"/ #V_STRING
    1875 ###       when /\A"([^"]*)"/m #V_STRING
    1876 ###         yield :V_STRING, $1
    1877       when /\A[a-z]+:\/\/[^<>|\\{}^~"\[\] ]*/ #V_URI
    1878         yield :V_URI, $&
    1879 ###       when /\AP([0-9]+[yY])?([0-9]+[mM])?([0-9]+[wW])?([0-9]+[dD])?T([0-9]+[hH])?([0-9]+[mM])?([0-9]+[sS])?|P([0-9]+[yY])?([0-9]+[mM])?([0-9]+[wW])?([0-9]+[dD])?/   #V_ISO8601_DURATION PnYnMnWnDTnnHnnMnnS
    1880 ###         yield :V_ISO8601_DURATION, $&
    1881       when /\A\S/ #UTF8CHAR
    1882         yield :UTF8CHAR, $&
    1883       end
    1884       data = $' # variable $' receives the string after the match
    1885     when :adl
    1886       data = scan_adl(data) do |sym, val|
    1887         yield sym, val
    1888       end
    1889     when :cadl
    1890       data = scan_cadl(data) do |sym, val|
    1891         yield sym, val
    1892       end
    1893     when :regexp
    1894 #      puts "Entering scan_regexp"
    1895       data = scan_regexp(data) do |sym, val|
    1896         yield sym, val
    1897       end
    1898     when :term_constraint
    1899       @@logger.debug("#{__FILE__}:#{__LINE__}: scan_dadl: Entering scan_term_constraint at #{@filename}:#{@lineno}: data = #{data.inspect}")
    1900 
    1901       data = scan_term_constraint(data) do |sym, val|
    1902         yield sym, val
    1903       end
    1904     else
    1905       raise
    1906     end
    1907   end
    1908 end # of scan_dadl
    1909 
    1910 def scan_regexp(data)
    1911   @@logger.debug("#{__FILE__}:#{__LINE__}: Entering scan_regexp at #{@filename}:#{@lineno}: data = #{data.inspect}")
    1912   until data.nil?  do
    1913     case @adl_type.last
    1914     when :regexp
    1915       case data
    1916       when /\A\/\}/ #V_REGEXP
    1917         if @adl_type.last == :regexp
    1918           @in_regexp = false
    1919           @adl_type.pop
    1920           yield :END_REGEXP_BLOCK, :END_REGEXP_BLOCK
    1921         else
    1922           raise
    1923         end
    1924       when /\A(.*)(\/\})/ #V_REGEXP
    1925         yield :REGEXP_BODY, $1
    1926         if @adl_type.last == :regexp
    1927           @in_regexp = false
    1928           @adl_type.pop
    1929           yield :END_REGEXP_BLOCK, :END_REGEXP_BLOCK
    1930         else
    1931           raise
    1932         end
    1933       else
    1934         raise data
    1935       end
    1936       data = $' # variable $' receives the string after the match
    1937     when :adl
    1938       data = scan_adl(data) do |sym, val|
    1939         yield sym, val
    1940       end
    1941     when :dadl
    1942       data = scan_dadl(data) do |sym, val|
    1943         yield sym, val
    1944       end
    1945     when :cadl
    1946       data = scan_cadl(data) do |sym, val|
    1947         yield sym, val
    1948       end
    1949     when :term_constraint
    1950       @@logger.debug("#{__FILE__}:#{__LINE__}: scan_regexp: Entering scan_term_constraint at #{@filename}:#{@lineno}")
    1951       data = scan_term_constraint(data) do |sym, val|
    1952         yield sym, val
    1953       end
    1954     else
    1955       raise
    1956     end
    1957   end
    1958 end # of scan_regexp
    1959 
    1960 def scan_term_constraint(data)
    1961   @@logger.debug("#{__FILE__}:#{__LINE__}: Entering scan_term_constraint")
    1962   until data.nil?  do
    1963     case @adl_type.last
    1964     when :term_constraint
    1965       case data
    1966       when /\A\n/ # carriage return
    1967         @lineno += 1
    1968         ;
    1969       when /\A[ \t\r\f]+/ #just drop it
    1970         ;
    1971       when /\A--.*$/ # single line comment
    1972         @lineno += 1
    1973         #@@logger.debug("#{__FILE__}:#{__LINE__}: scan_term_constraint: COMMENT = #{$&} at #{@filename}:#{@lineno}")
    1974         ;
    1975       when /\A([a-zA-Z0-9\._\-])+[ \t]*,/ # match any line, with ',' termination
    1976         yield :TERM_CODE, $1
    1977       when /\A([a-zA-Z0-9\._\-])+[ \t]*;/ # match second last line with ';' termination (assumed value)
    1978         yield :TERM_CODE, $1
    1979       when /\A([a-zA-Z0-9\._\-])*[ \t]*\]/ # match final line, terminating in ']'
    1980         adl_type = @adl_type.pop
    1981         assert_at(__FILE__,__LINE__){adl_type == :term_constraint}
    1982         yield :END_TERM_CODE_CONSTRAINT, $1
    1983       else
    1984         raise "data = #{data}"
    1985       end
    1986       data = $' # variable $' receives the string after the match
    1987     when :adl
    1988       data = scan_adl(data) do |sym, val|
    1989         yield sym, val
    1990       end
    1991     when :dadl
    1992       data = scan_dadl(data) do |sym, val|
    1993         yield sym, val
    1994       end
    1995     when :cadl
    1996       data = scan_cadl(data) do |sym, val|
    1997         yield sym, val
    1998       end
    1999     else
    2000       raise
    2001     end
    2002   end
    2003 end # of scan_term_constraint
    20041296
    20051297
    … …  
    20221314
    20231315
    2024 
     1316__END__
    20251317
    20261318
Note: See TracChangeset for help on using the changeset viewer.