← Back to branch summary

~rdoering/ubuntu/karmic/erlang/fix-535090

« back to all changes in this revision

Viewing changes to lib/megaco/src/text/megaco_text_parser_prev3b.hrl

  • Committer: Bazaar Package Importer
  • Author(s): Sergei Golovan
  • Date: 2009-02-15 16:42:52 UTC
  • mfrom: (1.1.13 upstream)
  • mto: (3.3.1 squeeze)
  • mto: This revision was merged to the branch mainline in revision 17.
  • Revision ID: james.westby@ubuntu.com-20090215164252-dxpjjuq108nz4noa
Upload to unstable after lenny is released.

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/megaco/src/text/megaco_text_parser_prev3b.hrl
1477
1477
    TSD#'TerminationStateDescriptor'{propertyParms = lists:reverse(PP)}.
1478
1478
 
1479
1479
 
 
1480
-ifdef(megaco_nscanner_props).
 
1481
 
1480
1482
-ifdef(megaco_parser_inline).
1481
1483
-compile({inline,[{ensure_prop_groups,1}]}).
1482
1484
-endif.
1483
1485
ensure_prop_groups(Token) ->
1484
1486
    {_TokenTag, _Line, Text} = Token,
1485
1487
    Group  = [],
1486
 
    Groups = [],
1487
 
    parse_prop_name(Text, Group, Groups).
 
1488
    parse_prop_name(Text, Group).
1488
1489
 
1489
 
parse_prop_name([Char | Rest] = All, Group, Groups) ->
 
1490
parse_prop_name([Char | Rest] = All, Group) ->
1490
1491
    if 
1491
1492
        ?white_space(Char) ->
1492
 
            parse_prop_name(Rest, Group, Groups);
 
1493
            parse_prop_name(Rest, Group);
1493
1494
        ?end_of_line(Char) ->
1494
 
            parse_prop_name(Rest, Group, Groups);
 
1495
            parse_prop_name(Rest, Group);
1495
1496
        true ->
1496
1497
            Name = [],
1497
 
            do_parse_prop_name(All, Name, Group, Groups)
 
1498
            do_parse_prop_name(All, Name, Group)
1498
1499
    end;
1499
 
parse_prop_name([] = All, Group, Groups) ->
 
1500
parse_prop_name([] = All, Group) ->
1500
1501
    Name = [],
1501
 
    do_parse_prop_name(All, Name, Group, Groups).
 
1502
    do_parse_prop_name(All, Name, Group).
1502
1503
 
1503
 
do_parse_prop_name([Char | Rest], Name, Group, Groups) 
 
1504
do_parse_prop_name([Char | Rest], Name, Group) 
1504
1505
  when (Char =:= $=) andalso (Name =/= []) ->
1505
1506
    %% Now we have a complete name
1506
1507
    if
1507
1508
        (Name =:= "v") andalso (Group =/= []) ->
1508
1509
            %% v= is a property group delimiter,
1509
1510
            %% lets create yet another property group.
1510
 
            Groups2 = [lists:reverse(Group) | Groups],
1511
 
            Group2 = [],
1512
 
            parse_prop_value(Rest, Name, Group2, Groups2);
 
1511
            NewGroup = [],
 
1512
            [lists:reverse(Group) | parse_prop_value(Rest, Name, NewGroup)];
1513
1513
        true ->
1514
1514
            %% Use current property group
1515
 
            parse_prop_value(Rest, Name, Group, Groups)
 
1515
            parse_prop_value(Rest, Name, Group)
1516
1516
    end;
1517
 
do_parse_prop_name([Char | Rest], Name, Group, Groups) ->
 
1517
do_parse_prop_name([Char | Rest], Name, Group) ->
1518
1518
    case ?classify_char4(Char) of
1519
1519
        safe_char_upper ->
1520
 
            do_parse_prop_name(Rest, [Char | Name], Group, Groups);
 
1520
            do_parse_prop_name(Rest, [Char | Name], Group);
1521
1521
        safe_char ->
1522
 
            do_parse_prop_name(Rest, [Char | Name], Group, Groups);
 
1522
            do_parse_prop_name(Rest, [Char | Name], Group);
1523
1523
        _ ->
1524
1524
            return_error(0, {bad_prop_name, lists:reverse(Name), Char})
1525
1525
    end;
1526
 
do_parse_prop_name([], [], [], Groups) ->
1527
 
    lists:reverse(Groups);
1528
 
do_parse_prop_name([], [], Group, Groups) ->
1529
 
    Group2 = lists:reverse(Group),
1530
 
    lists:reverse([Group2 | Groups]);
1531
 
do_parse_prop_name([], Name, Group, Groups) when Name =/= [] ->
 
1526
do_parse_prop_name([], [], []) ->
 
1527
    [];
 
1528
do_parse_prop_name([], [], Group) ->
 
1529
    [lists:reverse(Group)];
 
1530
do_parse_prop_name([], Name, Group) when Name =/= [] ->
1532
1531
    %% Assume end of line
1533
1532
    Value = [],
1534
 
    PP = make_prop_parm(Name, Value),
 
1533
    PP     = make_prop_parm(Name, Value),
1535
1534
    Group2 = lists:reverse([PP | Group]),
1536
 
    lists:reverse([Group2 | Groups]).
1537
 
 
 
1535
    [Group2].
 
1536
                   
1538
1537
-ifdef(megaco_parser_inline).
1539
 
-compile({inline,[{parse_prop_value,4}]}).
 
1538
-compile({inline,[{parse_prop_value,3}]}).
1540
1539
-endif.
1541
 
parse_prop_value(Chars, Name, Group, Groups) ->
 
1540
parse_prop_value(Chars, Name, Group) ->
1542
1541
    Value = [],
1543
 
    do_parse_prop_value(Chars, Name, Value, Group, Groups).
 
1542
    do_parse_prop_value(Chars, Name, Value, Group).
1544
1543
 
1545
 
do_parse_prop_value([Char | Rest], Name, Value, Group, Groups) ->
 
1544
do_parse_prop_value([Char | Rest], Name, Value, Group) ->
1546
1545
    if
1547
1546
        ?end_of_line(Char) ->
1548
1547
            %% Now we have a complete "name=value" pair
1549
1548
            PP = make_prop_parm(Name, Value),
1550
 
            parse_prop_name(Rest, [PP | Group], Groups);
 
1549
            parse_prop_name(Rest, [PP | Group]);
1551
1550
        true ->
1552
 
            do_parse_prop_value(Rest, Name, [Char | Value], Group, Groups)
 
1551
            do_parse_prop_value(Rest, Name, [Char | Value], Group)
1553
1552
    end;
1554
 
do_parse_prop_value([], Name, Value, Group, Groups) ->
 
1553
do_parse_prop_value([], Name, Value, Group) ->
1555
1554
    %% Assume end of line
1556
 
    PP = make_prop_parm(Name, Value),
 
1555
    PP     = make_prop_parm(Name, Value),
1557
1556
    Group2 = lists:reverse([PP | Group]),
1558
 
    lists:reverse([Group2 | Groups]).
 
1557
    [Group2].
1559
1558
 
1560
1559
-ifdef(megaco_parser_inline).
1561
1560
-compile({inline,[{make_prop_parm,2}]}).
1564
1563
    #'PropertyParm'{name  = lists:reverse(Name),
1565
1564
                    value = [lists:reverse(Value)]}.
1566
1565
 
 
1566
-else. % -ifdef(megaco_nscanner_props).
 
1567
 
 
1568
-ifdef(megaco_parser_inline).
 
1569
-compile({inline,[{ensure_prop_groups,1}]}).
 
1570
-endif.
 
1571
ensure_prop_groups(Token) ->
 
1572
    {_TokenTag, _Line, Groups} = Token,
 
1573
    Groups.
 
1574
 
 
1575
%% do_ensure_prop_groups(Groups) when is_list(Groups) ->
 
1576
%%     [ensure_prop_group(Group) || Group <- Groups];
 
1577
%% do_ensure_prop_groups(BadGroups) ->
 
1578
%%     throw({error, {?MODULE, {bad_property_groups, BadGroups}}}).
 
1579
 
 
1580
%% -ifdef(megaco_parser_inline).
 
1581
%% -compile({inline,[{ensure_prop_group,1}]}).
 
1582
%% -endif.
 
1583
%% ensure_prop_group(Group) when is_list(Group) ->
 
1584
%%     [ensure_prop_parm(PropParm) || PropParm <- Group];
 
1585
%% ensure_prop_group(BadGroup) ->
 
1586
%%     throw({error, {?MODULE, {bad_property_group, BadGroup}}}).
 
1587
 
 
1588
%% -ifdef(megaco_parser_inline).
 
1589
%% -compile({inline,[{ensure_prop_parm,1}]}).
 
1590
%% -endif.
 
1591
%% ensure_prop_parm(#property_parm{name  = Name,
 
1592
%%                              value = Value}) ->
 
1593
%%     #'PropertyParm'{name  = Name,
 
1594
%%                     value = Value};
 
1595
%% ensure_prop_parm(PP) when is_record(PP, 'PropertyParm') ->
 
1596
%%     PP;
 
1597
%% ensure_prop_parm(BadPropParm) ->
 
1598
%%     throw({error, {?MODULE, {bad_property_parm, BadPropParm}}}).
 
1599
 
 
1600
-endif. % -ifdef(megaco_nscanner_props).
 
1601
 
1567
1602
-ifdef(megaco_parser_inline).
1568
1603
-compile({inline,[{ensure_uint,3}]}).
1569
1604
-endif.